AbstractWriter.cs 18.3 KB
Newer Older
1 2
using System;
using System.Collections;
3
using System.Collections.Generic;
4 5 6 7 8 9 10 11 12 13 14
using System.Globalization;
using Google.ProtocolBuffers.Descriptors;

//Disable CS3011: only CLS-compliant members can be abstract
#pragma warning disable 3011

namespace Google.ProtocolBuffers.Serialization
{
    /// <summary>
    /// Provides a base class for writers that performs some basic type dispatching
    /// </summary>
csharptest's avatar
csharptest committed
15
    public abstract class AbstractWriter : ICodedOutputStream
16 17 18 19 20
    {
        /// <summary>
        /// Completes any pending write operations
        /// </summary>
        public virtual void Flush()
21 22
        {
        }
23 24 25 26 27 28

        /// <summary>
        /// Writes the message to the the formatted stream.
        /// </summary>
        public abstract void WriteMessage(IMessageLite message);

29 30
        /// <summary>
        /// Used to write any nessary root-message preamble. After this call you can call 
31
        /// IMessageLite.MergeTo(...) and complete the message with a call to WriteMessageEnd().
32 33 34 35
        /// These three calls are identical to just calling WriteMessage(message);
        /// </summary>
        /// <example>
        /// AbstractWriter writer;
36
        /// writer.WriteMessageStart();
37
        /// message.WriteTo(writer);
38
        /// writer.WriteMessageEnd();
39 40 41
        /// // ... or, but not both ...
        /// writer.WriteMessage(message);
        /// </example>
42
        public abstract void WriteMessageStart();
43 44

        /// <summary>
45
        /// Used to complete a root-message previously started with a call to WriteMessageStart()
46
        /// </summary>
47
        public abstract void WriteMessageEnd();
48

49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
        /// <summary>
        /// Writes a Boolean value
        /// </summary>
        protected abstract void Write(string field, Boolean value);

        /// <summary>
        /// Writes a Int32 value
        /// </summary>
        protected abstract void Write(string field, Int32 value);

        /// <summary>
        /// Writes a UInt32 value
        /// </summary>
        [CLSCompliant(false)]
        protected abstract void Write(string field, UInt32 value);

        /// <summary>
        /// Writes a Int64 value
        /// </summary>
        protected abstract void Write(string field, Int64 value);

        /// <summary>
        /// Writes a UInt64 value
        /// </summary>
        [CLSCompliant(false)]
        protected abstract void Write(string field, UInt64 value);

        /// <summary>
        /// Writes a Single value
        /// </summary>
        protected abstract void Write(string field, Single value);

        /// <summary>
        /// Writes a Double value
        /// </summary>
        protected abstract void Write(string field, Double value);

        /// <summary>
        /// Writes a String value
        /// </summary>
        protected abstract void Write(string field, String value);

        /// <summary>
        /// Writes a set of bytes
        /// </summary>
        protected abstract void Write(string field, ByteString value);

        /// <summary>
        /// Writes a message or group as a field
        /// </summary>
        protected abstract void WriteMessageOrGroup(string field, IMessageLite message);

        /// <summary>
        /// Writes a System.Enum by the numeric and textual value
        /// </summary>
        protected abstract void WriteEnum(string field, int number, string name);

        /// <summary>
        /// Writes a field of the type determined by field.FieldType
        /// </summary>
        protected virtual void WriteField(FieldType fieldType, string field, object value)
        {
            switch (fieldType)
            {
113 114 115
                case FieldType.Bool:
                    Write(field, (bool) value);
                    break;
116 117
                case FieldType.Int64:
                case FieldType.SInt64:
118 119 120
                case FieldType.SFixed64:
                    Write(field, (long) value);
                    break;
121
                case FieldType.UInt64:
122 123 124
                case FieldType.Fixed64:
                    Write(field, (ulong) value);
                    break;
125 126
                case FieldType.Int32:
                case FieldType.SInt32:
127 128 129
                case FieldType.SFixed32:
                    Write(field, (int) value);
                    break;
130
                case FieldType.UInt32:
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
                case FieldType.Fixed32:
                    Write(field, (uint) value);
                    break;
                case FieldType.Float:
                    Write(field, (float) value);
                    break;
                case FieldType.Double:
                    Write(field, (double) value);
                    break;
                case FieldType.String:
                    Write(field, (string) value);
                    break;
                case FieldType.Bytes:
                    Write(field, (ByteString) value);
                    break;
                case FieldType.Group:
                    WriteMessageOrGroup(field, (IMessageLite) value);
                    break;
                case FieldType.Message:
                    WriteMessageOrGroup(field, (IMessageLite) value);
                    break;
152 153
                case FieldType.Enum:
                    {
154 155 156 157 158 159
                        if (value is IEnumLite)
                        {
                            WriteEnum(field, ((IEnumLite) value).Number, ((IEnumLite) value).Name);
                        }
                        else if (value is IConvertible)
                        {
160 161
                            WriteEnum(field, ((IConvertible)value).ToInt32(FrameworkPortability.InvariantCulture),
                                      ((IConvertible)value).ToString(FrameworkPortability.InvariantCulture));
162 163 164 165 166
                        }
                        else
                        {
                            throw new ArgumentException("Expected an Enum type for field " + field);
                        }
167 168 169 170 171 172 173 174 175 176 177 178 179
                        break;
                    }
                default:
                    throw InvalidProtocolBufferException.InvalidTag();
            }
        }

        /// <summary>
        /// Writes an array of field values
        /// </summary>
        protected virtual void WriteArray(FieldType fieldType, string field, IEnumerable items)
        {
            foreach (object obj in items)
180
            {
181
                WriteField(fieldType, field, obj);
182
            }
183 184 185 186 187 188 189
        }

        /// <summary>
        /// Writes a numeric unknown field of wire type: Fixed32, Fixed64, or Variant
        /// </summary>
        [CLSCompliant(false)]
        protected virtual void WriteUnknown(WireFormat.WireType wireType, int fieldNumber, ulong value)
190 191
        {
        }
192 193 194 195 196 197

        /// <summary>
        /// Writes an unknown field, Expect WireType of GroupStart or LengthPrefix
        /// </summary>
        [CLSCompliant(false)]
        protected virtual void WriteUnknown(WireFormat.WireType wireType, int fieldNumber, ByteString value)
198 199
        {
        }
200 201 202 203

        #region ICodedOutputStream Members

        void ICodedOutputStream.WriteUnknownGroup(int fieldNumber, IMessageLite value)
204 205 206
        {
        }

207
        void ICodedOutputStream.WriteUnknownBytes(int fieldNumber, ByteString value)
208 209 210
        {
        }

211
        void ICodedOutputStream.WriteUnknownField(int fieldNumber, WireFormat.WireType type, ulong value)
212 213
        {
        }
214 215

        void ICodedOutputStream.WriteMessageSetExtension(int fieldNumber, string fieldName, IMessageLite value)
216 217
        {
        }
218 219

        void ICodedOutputStream.WriteMessageSetExtension(int fieldNumber, string fieldName, ByteString value)
220 221
        {
        }
222 223

        void ICodedOutputStream.WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value)
224 225 226
        {
            WriteField(fieldType, fieldName, value);
        }
227 228

        void ICodedOutputStream.WriteDouble(int fieldNumber, string fieldName, double value)
229 230 231
        {
            Write(fieldName, value);
        }
232 233

        void ICodedOutputStream.WriteFloat(int fieldNumber, string fieldName, float value)
234 235 236
        {
            Write(fieldName, value);
        }
237 238

        void ICodedOutputStream.WriteUInt64(int fieldNumber, string fieldName, ulong value)
239 240 241
        {
            Write(fieldName, value);
        }
242 243

        void ICodedOutputStream.WriteInt64(int fieldNumber, string fieldName, long value)
244 245 246
        {
            Write(fieldName, value);
        }
247 248

        void ICodedOutputStream.WriteInt32(int fieldNumber, string fieldName, int value)
249 250 251
        {
            Write(fieldName, value);
        }
252 253

        void ICodedOutputStream.WriteFixed64(int fieldNumber, string fieldName, ulong value)
254 255 256
        {
            Write(fieldName, value);
        }
257 258

        void ICodedOutputStream.WriteFixed32(int fieldNumber, string fieldName, uint value)
259 260 261
        {
            Write(fieldName, value);
        }
262 263

        void ICodedOutputStream.WriteBool(int fieldNumber, string fieldName, bool value)
264 265 266
        {
            Write(fieldName, value);
        }
267 268

        void ICodedOutputStream.WriteString(int fieldNumber, string fieldName, string value)
269 270 271
        {
            Write(fieldName, value);
        }
272 273

        void ICodedOutputStream.WriteGroup(int fieldNumber, string fieldName, IMessageLite value)
274 275 276
        {
            WriteMessageOrGroup(fieldName, value);
        }
277 278

        void ICodedOutputStream.WriteMessage(int fieldNumber, string fieldName, IMessageLite value)
279 280 281
        {
            WriteMessageOrGroup(fieldName, value);
        }
282 283

        void ICodedOutputStream.WriteBytes(int fieldNumber, string fieldName, ByteString value)
284 285 286
        {
            Write(fieldName, value);
        }
287 288

        void ICodedOutputStream.WriteUInt32(int fieldNumber, string fieldName, uint value)
289 290 291
        {
            Write(fieldName, value);
        }
292 293

        void ICodedOutputStream.WriteEnum(int fieldNumber, string fieldName, int value, object rawValue)
294 295 296
        {
            WriteEnum(fieldName, value, rawValue.ToString());
        }
297 298

        void ICodedOutputStream.WriteSFixed32(int fieldNumber, string fieldName, int value)
299 300 301
        {
            Write(fieldName, value);
        }
302 303

        void ICodedOutputStream.WriteSFixed64(int fieldNumber, string fieldName, long value)
304 305 306
        {
            Write(fieldName, value);
        }
307 308

        void ICodedOutputStream.WriteSInt32(int fieldNumber, string fieldName, int value)
309 310 311
        {
            Write(fieldName, value);
        }
312 313

        void ICodedOutputStream.WriteSInt64(int fieldNumber, string fieldName, long value)
314 315 316
        {
            Write(fieldName, value);
        }
317 318 319


        void ICodedOutputStream.WriteArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list)
320 321 322
        {
            WriteArray(fieldType, fieldName, list);
        }
323

324 325 326 327
        void ICodedOutputStream.WriteGroupArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
        {
            WriteArray(FieldType.Group, fieldName, list);
        }
328

329 330 331 332
        void ICodedOutputStream.WriteMessageArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
        {
            WriteArray(FieldType.Message, fieldName, list);
        }
333

334 335 336 337
        void ICodedOutputStream.WriteStringArray(int fieldNumber, string fieldName, IEnumerable<string> list)
        {
            WriteArray(FieldType.String, fieldName, list);
        }
338

339 340 341 342
        void ICodedOutputStream.WriteBytesArray(int fieldNumber, string fieldName, IEnumerable<ByteString> list)
        {
            WriteArray(FieldType.Bytes, fieldName, list);
        }
343

344 345 346 347
        void ICodedOutputStream.WriteBoolArray(int fieldNumber, string fieldName, IEnumerable<bool> list)
        {
            WriteArray(FieldType.Bool, fieldName, list);
        }
348

349 350 351 352
        void ICodedOutputStream.WriteInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
        {
            WriteArray(FieldType.Int32, fieldName, list);
        }
353

354 355 356 357
        void ICodedOutputStream.WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
        {
            WriteArray(FieldType.SInt32, fieldName, list);
        }
358

359 360 361 362
        void ICodedOutputStream.WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable<uint> list)
        {
            WriteArray(FieldType.UInt32, fieldName, list);
        }
363

364 365 366 367
        void ICodedOutputStream.WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable<uint> list)
        {
            WriteArray(FieldType.Fixed32, fieldName, list);
        }
368

369 370 371 372
        void ICodedOutputStream.WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
        {
            WriteArray(FieldType.SFixed32, fieldName, list);
        }
373

374 375 376 377
        void ICodedOutputStream.WriteInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
        {
            WriteArray(FieldType.Int64, fieldName, list);
        }
378

379 380 381 382
        void ICodedOutputStream.WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
        {
            WriteArray(FieldType.SInt64, fieldName, list);
        }
383

384 385 386 387
        void ICodedOutputStream.WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list)
        {
            WriteArray(FieldType.UInt64, fieldName, list);
        }
388

389 390 391 392
        void ICodedOutputStream.WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list)
        {
            WriteArray(FieldType.Fixed64, fieldName, list);
        }
393

394 395 396 397
        void ICodedOutputStream.WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
        {
            WriteArray(FieldType.SFixed64, fieldName, list);
        }
398

399 400 401 402
        void ICodedOutputStream.WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable<double> list)
        {
            WriteArray(FieldType.Double, fieldName, list);
        }
403

404 405 406 407
        void ICodedOutputStream.WriteFloatArray(int fieldNumber, string fieldName, IEnumerable<float> list)
        {
            WriteArray(FieldType.Float, fieldName, list);
        }
408

409 410 411 412
        void ICodedOutputStream.WriteEnumArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
        {
            WriteArray(FieldType.Enum, fieldName, list);
        }
413

414 415 416 417 418
        void ICodedOutputStream.WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName,
                                                 IEnumerable list)
        {
            WriteArray(fieldType, fieldName, list);
        }
419 420


421 422 423 424 425
        void ICodedOutputStream.WritePackedBoolArray(int fieldNumber, string fieldName, int computedSize,
                                                     IEnumerable<bool> list)
        {
            WriteArray(FieldType.Bool, fieldName, list);
        }
426

427 428 429 430 431
        void ICodedOutputStream.WritePackedInt32Array(int fieldNumber, string fieldName, int computedSize,
                                                      IEnumerable<int> list)
        {
            WriteArray(FieldType.Int32, fieldName, list);
        }
432

433 434 435 436 437
        void ICodedOutputStream.WritePackedSInt32Array(int fieldNumber, string fieldName, int computedSize,
                                                       IEnumerable<int> list)
        {
            WriteArray(FieldType.SInt32, fieldName, list);
        }
438

439 440 441 442 443
        void ICodedOutputStream.WritePackedUInt32Array(int fieldNumber, string fieldName, int computedSize,
                                                       IEnumerable<uint> list)
        {
            WriteArray(FieldType.UInt32, fieldName, list);
        }
444

445 446 447 448 449
        void ICodedOutputStream.WritePackedFixed32Array(int fieldNumber, string fieldName, int computedSize,
                                                        IEnumerable<uint> list)
        {
            WriteArray(FieldType.Fixed32, fieldName, list);
        }
450

451 452 453 454 455
        void ICodedOutputStream.WritePackedSFixed32Array(int fieldNumber, string fieldName, int computedSize,
                                                         IEnumerable<int> list)
        {
            WriteArray(FieldType.SFixed32, fieldName, list);
        }
456

457 458 459 460 461
        void ICodedOutputStream.WritePackedInt64Array(int fieldNumber, string fieldName, int computedSize,
                                                      IEnumerable<long> list)
        {
            WriteArray(FieldType.Int64, fieldName, list);
        }
462

463 464 465 466 467
        void ICodedOutputStream.WritePackedSInt64Array(int fieldNumber, string fieldName, int computedSize,
                                                       IEnumerable<long> list)
        {
            WriteArray(FieldType.SInt64, fieldName, list);
        }
468

469 470 471 472 473
        void ICodedOutputStream.WritePackedUInt64Array(int fieldNumber, string fieldName, int computedSize,
                                                       IEnumerable<ulong> list)
        {
            WriteArray(FieldType.UInt64, fieldName, list);
        }
474

475 476 477 478 479
        void ICodedOutputStream.WritePackedFixed64Array(int fieldNumber, string fieldName, int computedSize,
                                                        IEnumerable<ulong> list)
        {
            WriteArray(FieldType.Fixed64, fieldName, list);
        }
480

481 482 483 484 485
        void ICodedOutputStream.WritePackedSFixed64Array(int fieldNumber, string fieldName, int computedSize,
                                                         IEnumerable<long> list)
        {
            WriteArray(FieldType.SFixed64, fieldName, list);
        }
486

487 488 489 490 491
        void ICodedOutputStream.WritePackedDoubleArray(int fieldNumber, string fieldName, int computedSize,
                                                       IEnumerable<double> list)
        {
            WriteArray(FieldType.Double, fieldName, list);
        }
492

493 494 495 496 497
        void ICodedOutputStream.WritePackedFloatArray(int fieldNumber, string fieldName, int computedSize,
                                                      IEnumerable<float> list)
        {
            WriteArray(FieldType.Float, fieldName, list);
        }
498

499 500 501 502 503
        void ICodedOutputStream.WritePackedEnumArray<T>(int fieldNumber, string fieldName, int computedSize,
                                                        IEnumerable<T> list)
        {
            WriteArray(FieldType.Enum, fieldName, list);
        }
504 505 506

        #endregion
    }
507
}