From 74c5e0c3762939fbf5988daf6f97c5d9c97ef4f5 Mon Sep 17 00:00:00 2001 From: csharptest Date: Thu, 14 Jul 2011 13:06:22 -0500 Subject: Reformatted to include braces --- src/ProtocolBuffers/AbstractBuilder.cs | 1 - src/ProtocolBuffers/AbstractBuilderLite.cs | 2 - src/ProtocolBuffers/AbstractMessage.cs | 35 +- src/ProtocolBuffers/AbstractMessageLite.cs | 2 - src/ProtocolBuffers/ByteArray.cs | 17 +- src/ProtocolBuffers/ByteString.cs | 7 +- src/ProtocolBuffers/CodedInputStream.cs | 96 ++++-- .../CodedOutputStream.ComputeSize.cs | 82 ++++- src/ProtocolBuffers/CodedOutputStream.cs | 344 ++++++++++++------ src/ProtocolBuffers/Collections/PopsicleList.cs | 21 +- src/ProtocolBuffers/Descriptors/DescriptorPool.cs | 2 +- src/ProtocolBuffers/Descriptors/EnumDescriptor.cs | 1 + .../Descriptors/FieldMappingAttribute.cs | 6 +- src/ProtocolBuffers/DynamicMessage.cs | 5 +- src/ProtocolBuffers/EnumLite.cs | 19 +- src/ProtocolBuffers/ExtendableBuilderLite.cs | 43 ++- src/ProtocolBuffers/ExtendableMessageLite.cs | 5 +- src/ProtocolBuffers/ExtensionRegistry.cs | 6 +- src/ProtocolBuffers/ExtensionRegistryLite.cs | 26 +- .../FieldAccess/SinglePrimitiveAccessor.cs | 5 +- src/ProtocolBuffers/FieldSet.cs | 57 ++- src/ProtocolBuffers/GeneratedBuilderLite.cs | 1 - src/ProtocolBuffers/GeneratedExtensionLite.cs | 6 +- src/ProtocolBuffers/GeneratedMessage.cs | 36 +- src/ProtocolBuffers/GeneratedMessageLite.cs | 25 +- src/ProtocolBuffers/GeneratedRepeatExtension.cs | 2 +- src/ProtocolBuffers/IBuilderLite.cs | 2 - src/ProtocolBuffers/ICodedInputStream.cs | 11 +- src/ProtocolBuffers/ICodedOutputStream.cs | 46 ++- src/ProtocolBuffers/IMessageLite.cs | 2 - src/ProtocolBuffers/IRpcDispatch.cs | 2 - src/ProtocolBuffers/MessageStreamIterator.cs | 6 +- src/ProtocolBuffers/NameHelpers.cs | 2 +- .../Serialization/AbstractReader.cs | 278 +++++++++++---- .../Serialization/AbstractTextReader.cs | 25 +- .../Serialization/AbstractTextWriter.cs | 55 ++- .../Serialization/AbstractWriter.cs | 384 +++++++++++++++------ .../Serialization/DictionaryReader.cs | 51 ++- .../Serialization/DictionaryWriter.cs | 29 +- .../Serialization/JsonFormatReader.cs | 90 +++-- .../Serialization/JsonFormatWriter.cs | 176 ++++++++-- .../Serialization/JsonTextCursor.cs | 184 ++++++++-- .../Serialization/XmlFormatReader.cs | 95 +++-- .../Serialization/XmlFormatWriter.cs | 106 ++++-- .../Serialization/XmlReaderOptions.cs | 1 + .../Serialization/XmlWriterOptions.cs | 3 + src/ProtocolBuffers/TextFormat.cs | 14 +- src/ProtocolBuffers/UnknownFieldSet.cs | 95 ++++- src/ProtocolBuffers/WireFormat.cs | 1 + 49 files changed, 1802 insertions(+), 708 deletions(-) (limited to 'src/ProtocolBuffers') diff --git a/src/ProtocolBuffers/AbstractBuilder.cs b/src/ProtocolBuffers/AbstractBuilder.cs index ca7e3649..e477194c 100644 --- a/src/ProtocolBuffers/AbstractBuilder.cs +++ b/src/ProtocolBuffers/AbstractBuilder.cs @@ -37,7 +37,6 @@ using System; using System.Collections; using System.Collections.Generic; -using System.IO; using Google.ProtocolBuffers.Descriptors; namespace Google.ProtocolBuffers diff --git a/src/ProtocolBuffers/AbstractBuilderLite.cs b/src/ProtocolBuffers/AbstractBuilderLite.cs index 8ab0ca97..8899d9b2 100644 --- a/src/ProtocolBuffers/AbstractBuilderLite.cs +++ b/src/ProtocolBuffers/AbstractBuilderLite.cs @@ -35,8 +35,6 @@ #endregion using System; -using System.Collections; -using System.Collections.Generic; using System.IO; namespace Google.ProtocolBuffers diff --git a/src/ProtocolBuffers/AbstractMessage.cs b/src/ProtocolBuffers/AbstractMessage.cs index 52401acd..0c898c70 100644 --- a/src/ProtocolBuffers/AbstractMessage.cs +++ b/src/ProtocolBuffers/AbstractMessage.cs @@ -37,8 +37,10 @@ using System.Collections; using System.Collections.Generic; using System.IO; +using System.Text; using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.Serialization; namespace Google.ProtocolBuffers { @@ -123,22 +125,22 @@ namespace Google.ProtocolBuffers public string ToJson() { - Serialization.JsonFormatWriter w = Serialization.JsonFormatWriter.CreateInstance(); + JsonFormatWriter w = JsonFormatWriter.CreateInstance(); w.WriteMessage(this); return w.ToString(); } public string ToXml() { - StringWriter w = new StringWriter(new System.Text.StringBuilder(4096)); - Serialization.XmlFormatWriter.CreateInstance(w).WriteMessage(this); + StringWriter w = new StringWriter(new StringBuilder(4096)); + XmlFormatWriter.CreateInstance(w).WriteMessage(this); return w.ToString(); } public string ToXml(string rootElementName) { - StringWriter w = new StringWriter(new System.Text.StringBuilder(4096)); - Serialization.XmlFormatWriter.CreateInstance(w).WriteMessage(rootElementName, this); + StringWriter w = new StringWriter(new StringBuilder(4096)); + XmlFormatWriter.CreateInstance(w).WriteMessage(rootElementName, this); return w.ToString(); } @@ -170,28 +172,13 @@ namespace Google.ProtocolBuffers // IEnumerable is the best we can do. (C# generics aren't covariant yet.) IEnumerable valueList = (IEnumerable) entry.Value; if (field.IsPacked) + { output.WritePackedArray(field.FieldType, field.FieldNumber, field.Name, valueList); - //{ - // output.WriteTag(field.FieldNumber, WireFormat.WireType.LengthDelimited); - // int dataSize = 0; - // foreach (object element in valueList) - // { - // dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element); - // } - // output.WriteRawVarint32((uint) dataSize); - // foreach (object element in valueList) - // { - // output.WriteFieldNoTag(field.FieldType, element); - // } - //} + } else + { output.WriteArray(field.FieldType, field.FieldNumber, field.Name, valueList); - //{ - // foreach (object element in valueList) - // { - // output.WriteField(field.FieldType, field.FieldNumber, field.Name, element); - // } - //} + } } else { diff --git a/src/ProtocolBuffers/AbstractMessageLite.cs b/src/ProtocolBuffers/AbstractMessageLite.cs index 407238bf..021cb0ef 100644 --- a/src/ProtocolBuffers/AbstractMessageLite.cs +++ b/src/ProtocolBuffers/AbstractMessageLite.cs @@ -34,8 +34,6 @@ #endregion -using System.Collections; -using System.Collections.Generic; using System.IO; namespace Google.ProtocolBuffers diff --git a/src/ProtocolBuffers/ByteArray.cs b/src/ProtocolBuffers/ByteArray.cs index 7c92449c..3c51b7b0 100644 --- a/src/ProtocolBuffers/ByteArray.cs +++ b/src/ProtocolBuffers/ByteArray.cs @@ -34,27 +34,35 @@ #endregion +using System; + namespace Google.ProtocolBuffers { /// /// Provides a utility routine to copy small arrays much more quickly than Buffer.BlockCopy /// - static class ByteArray + internal static class ByteArray { /// /// The threshold above which you should use Buffer.BlockCopy rather than ByteArray.Copy /// - const int CopyThreshold = 12; + private const int CopyThreshold = 12; + /// /// Determines which copy routine to use based on the number of bytes to be copied. /// public static void Copy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int count) { if (count > CopyThreshold) - global::System.Buffer.BlockCopy(src, srcOffset, dst, dstOffset, count); + { + Buffer.BlockCopy(src, srcOffset, dst, dstOffset, count); + } else + { ByteCopy(src, srcOffset, dst, dstOffset, count); + } } + /// /// Copy the bytes provided with a for loop, faster when there are only a few bytes to copy /// @@ -62,8 +70,11 @@ namespace Google.ProtocolBuffers { int stop = srcOffset + count; for (int i = srcOffset; i < stop; i++) + { dst[dstOffset++] = src[i]; + } } + /// /// Reverses the order of bytes in the array /// diff --git a/src/ProtocolBuffers/ByteString.cs b/src/ProtocolBuffers/ByteString.cs index e5f422d4..545bf556 100644 --- a/src/ProtocolBuffers/ByteString.cs +++ b/src/ProtocolBuffers/ByteString.cs @@ -37,6 +37,7 @@ using System; using System.Collections; using System.Collections.Generic; +using System.IO; using System.Text; namespace Google.ProtocolBuffers @@ -91,7 +92,7 @@ namespace Google.ProtocolBuffers public byte[] ToByteArray() { - return (byte[])bytes.Clone(); + return (byte[]) bytes.Clone(); } public string ToBase64() @@ -104,7 +105,7 @@ namespace Google.ProtocolBuffers /// public static ByteString FromBase64(string bytes) { - return new ByteString(System.Convert.FromBase64String(bytes)); + return new ByteString(Convert.FromBase64String(bytes)); } /// @@ -267,7 +268,7 @@ namespace Google.ProtocolBuffers /// /// Writes the entire byte array to the provided stream /// - public void WriteTo(System.IO.Stream outputStream) + public void WriteTo(Stream outputStream) { outputStream.Write(bytes, 0, bytes.Length); } diff --git a/src/ProtocolBuffers/CodedInputStream.cs b/src/ProtocolBuffers/CodedInputStream.cs index 72f5d2f6..c367cc3c 100644 --- a/src/ProtocolBuffers/CodedInputStream.cs +++ b/src/ProtocolBuffers/CodedInputStream.cs @@ -165,7 +165,7 @@ namespace Google.ProtocolBuffers #endregion #region Reading of tags etc - + /// /// Attempt to peek at the next field tag. /// @@ -266,7 +266,9 @@ namespace Google.ProtocolBuffers { byte[] rawBytes = ReadRawBytes(4); if (!BitConverter.IsLittleEndian) + { ByteArray.Reverse(rawBytes); + } value = BitConverter.ToSingle(rawBytes, 0); } return true; @@ -296,7 +298,7 @@ namespace Google.ProtocolBuffers /// public bool ReadInt32(ref int value) { - value = (int)ReadRawVarint32(); + value = (int) ReadRawVarint32(); return true; } @@ -445,8 +447,8 @@ namespace Google.ProtocolBuffers /// public bool ReadEnum(ref IEnumLite value, out object unknown, IEnumLiteMap mapping) { - int rawValue = (int)ReadRawVarint32(); - + int rawValue = (int) ReadRawVarint32(); + value = mapping.FindValueByNumber(rawValue); if (value != null) { @@ -466,11 +468,11 @@ namespace Google.ProtocolBuffers public bool ReadEnum(ref T value, out object unknown) where T : struct, IComparable, IFormattable, IConvertible { - int number = (int)ReadRawVarint32(); - if (Enum.IsDefined(typeof(T), number)) + int number = (int) ReadRawVarint32(); + if (Enum.IsDefined(typeof (T), number)) { unknown = null; - value = (T)(object)number; + value = (T) (object) number; return true; } unknown = number; @@ -482,7 +484,7 @@ namespace Google.ProtocolBuffers /// public bool ReadSFixed32(ref int value) { - value = (int)ReadRawLittleEndian32(); + value = (int) ReadRawLittleEndian32(); return true; } @@ -491,7 +493,7 @@ namespace Google.ProtocolBuffers /// public bool ReadSFixed64(ref long value) { - value = (long)ReadRawLittleEndian64(); + value = (long) ReadRawLittleEndian64(); return true; } @@ -566,17 +568,19 @@ namespace Google.ProtocolBuffers { WireFormat.WireType normal = WireFormat.GetWireType(fieldType); WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag); - + // 2.3 allows packed form even if the field is not declared packed. - if(normal != wformat && wformat == WireFormat.WireType.LengthDelimited) + if (normal != wformat && wformat == WireFormat.WireType.LengthDelimited) { - int length = (int)(ReadRawVarint32() & int.MaxValue); + int length = (int) (ReadRawVarint32() & int.MaxValue); int limit = PushLimit(length); while (!ReachedLimit) { Object value = null; - if(ReadPrimitiveField(fieldType, ref value)) + if (ReadPrimitiveField(fieldType, ref value)) + { list.Add(value); + } } PopLimit(limit); } @@ -586,9 +590,10 @@ namespace Google.ProtocolBuffers do { if (ReadPrimitiveField(fieldType, ref value)) + { list.Add(value); - } - while (ContinueArray(fieldTag, false, 0)); + } + } while (ContinueArray(fieldTag, false, 0)); } } @@ -611,8 +616,7 @@ namespace Google.ProtocolBuffers { ReadBytes(ref tmp); list.Add(tmp); - } - while (ContinueArray(fieldTag, false, 0)); + } while (ContinueArray(fieldTag, false, 0)); } [CLSCompliant(false)] @@ -824,7 +828,8 @@ namespace Google.ProtocolBuffers } [CLSCompliant(false)] - public void ReadEnumArray(uint fieldTag, string fieldName, ICollection list, out ICollection unknown, IEnumLiteMap mapping) + public void ReadEnumArray(uint fieldTag, string fieldName, ICollection list, + out ICollection unknown, IEnumLiteMap mapping) { unknown = null; object unkval; @@ -834,16 +839,20 @@ namespace Google.ProtocolBuffers // 2.3 allows packed form even if the field is not declared packed. if (wformat == WireFormat.WireType.LengthDelimited) { - int length = (int)(ReadRawVarint32() & int.MaxValue); + int length = (int) (ReadRawVarint32() & int.MaxValue); int limit = PushLimit(length); while (!ReachedLimit) { if (ReadEnum(ref value, out unkval, mapping)) + { list.Add(value); + } else { if (unknown == null) + { unknown = new List(); + } unknown.Add(unkval); } } @@ -854,20 +863,24 @@ namespace Google.ProtocolBuffers do { if (ReadEnum(ref value, out unkval, mapping)) + { list.Add(value); + } else { if (unknown == null) + { unknown = new List(); + } unknown.Add(unkval); } - } - while (ContinueArray(fieldTag, false, 0)); + } while (ContinueArray(fieldTag, false, 0)); } } [CLSCompliant(false)] - public void ReadEnumArray(uint fieldTag, string fieldName, ICollection list, out ICollection unknown) + public void ReadEnumArray(uint fieldTag, string fieldName, ICollection list, + out ICollection unknown) where T : struct, IComparable, IFormattable, IConvertible { unknown = null; @@ -878,16 +891,20 @@ namespace Google.ProtocolBuffers // 2.3 allows packed form even if the field is not declared packed. if (wformat == WireFormat.WireType.LengthDelimited) { - int length = (int)(ReadRawVarint32() & int.MaxValue); + int length = (int) (ReadRawVarint32() & int.MaxValue); int limit = PushLimit(length); while (!ReachedLimit) { if (ReadEnum(ref value, out unkval)) + { list.Add(value); + } else { if (unknown == null) + { unknown = new List(); + } unknown.Add(unkval); } } @@ -898,40 +915,43 @@ namespace Google.ProtocolBuffers do { if (ReadEnum(ref value, out unkval)) + { list.Add(value); + } else { if (unknown == null) + { unknown = new List(); + } unknown.Add(unkval); } - } - while (ContinueArray(fieldTag, false, 0)); + } while (ContinueArray(fieldTag, false, 0)); } } [CLSCompliant(false)] - public void ReadMessageArray(uint fieldTag, string fieldName, ICollection list, T messageType, ExtensionRegistry registry) where T : IMessageLite + public void ReadMessageArray(uint fieldTag, string fieldName, ICollection list, T messageType, + ExtensionRegistry registry) where T : IMessageLite { do { IBuilderLite builder = messageType.WeakCreateBuilderForType(); ReadMessage(builder, registry); - list.Add((T)builder.WeakBuildPartial()); - } - while (ContinueArray(fieldTag, false, 0)); + list.Add((T) builder.WeakBuildPartial()); + } while (ContinueArray(fieldTag, false, 0)); } [CLSCompliant(false)] - public void ReadGroupArray(uint fieldTag, string fieldName, ICollection list, T messageType, ExtensionRegistry registry) where T : IMessageLite + public void ReadGroupArray(uint fieldTag, string fieldName, ICollection list, T messageType, + ExtensionRegistry registry) where T : IMessageLite { do { IBuilderLite builder = messageType.WeakCreateBuilderForType(); ReadGroup(WireFormat.GetTagFieldNumber(fieldTag), builder, registry); - list.Add((T)builder.WeakBuildPartial()); - } - while (ContinueArray(fieldTag, false, 0)); + list.Add((T) builder.WeakBuildPartial()); + } while (ContinueArray(fieldTag, false, 0)); } /// @@ -1148,7 +1168,10 @@ namespace Google.ProtocolBuffers // Discard upper 32 bits. for (int i = 0; i < 5; i++) { - if (ReadRawByte() < 128) return (uint) result; + if (ReadRawByte() < 128) + { + return (uint) result; + } } throw InvalidProtocolBufferException.MalformedVarint(); } @@ -1208,7 +1231,10 @@ namespace Google.ProtocolBuffers // use the fast path in more cases, and we rarely hit this section of code. for (int i = 0; i < 5; i++) { - if (ReadRawByte() < 128) return (uint) result; + if (ReadRawByte() < 128) + { + return (uint) result; + } } throw InvalidProtocolBufferException.MalformedVarint(); } diff --git a/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs b/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs index 5533ed5b..ef197d8f 100644 --- a/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs +++ b/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs @@ -36,7 +36,6 @@ using System; using System.Globalization; -using System.IO; using System.Text; using Google.ProtocolBuffers.Descriptors; @@ -477,10 +476,22 @@ namespace Google.ProtocolBuffers [CLSCompliant(false)] public static int ComputeRawVarint32Size(uint value) { - if ((value & (0xffffffff << 7)) == 0) return 1; - if ((value & (0xffffffff << 14)) == 0) return 2; - if ((value & (0xffffffff << 21)) == 0) return 3; - if ((value & (0xffffffff << 28)) == 0) return 4; + if ((value & (0xffffffff << 7)) == 0) + { + return 1; + } + if ((value & (0xffffffff << 14)) == 0) + { + return 2; + } + if ((value & (0xffffffff << 21)) == 0) + { + return 3; + } + if ((value & (0xffffffff << 28)) == 0) + { + return 4; + } return 5; } @@ -490,15 +501,42 @@ namespace Google.ProtocolBuffers [CLSCompliant(false)] public static int ComputeRawVarint64Size(ulong value) { - if ((value & (0xffffffffffffffffL << 7)) == 0) return 1; - if ((value & (0xffffffffffffffffL << 14)) == 0) return 2; - if ((value & (0xffffffffffffffffL << 21)) == 0) return 3; - if ((value & (0xffffffffffffffffL << 28)) == 0) return 4; - if ((value & (0xffffffffffffffffL << 35)) == 0) return 5; - if ((value & (0xffffffffffffffffL << 42)) == 0) return 6; - if ((value & (0xffffffffffffffffL << 49)) == 0) return 7; - if ((value & (0xffffffffffffffffL << 56)) == 0) return 8; - if ((value & (0xffffffffffffffffL << 63)) == 0) return 9; + if ((value & (0xffffffffffffffffL << 7)) == 0) + { + return 1; + } + if ((value & (0xffffffffffffffffL << 14)) == 0) + { + return 2; + } + if ((value & (0xffffffffffffffffL << 21)) == 0) + { + return 3; + } + if ((value & (0xffffffffffffffffL << 28)) == 0) + { + return 4; + } + if ((value & (0xffffffffffffffffL << 35)) == 0) + { + return 5; + } + if ((value & (0xffffffffffffffffL << 42)) == 0) + { + return 6; + } + if ((value & (0xffffffffffffffffL << 49)) == 0) + { + return 7; + } + if ((value & (0xffffffffffffffffL << 56)) == 0) + { + return 8; + } + if ((value & (0xffffffffffffffffL << 63)) == 0) + { + return 9; + } return 10; } @@ -545,10 +583,14 @@ namespace Google.ProtocolBuffers case FieldType.SInt64: return ComputeSInt64Size(fieldNumber, (long) value); case FieldType.Enum: - if (value is System.Enum) - return ComputeEnumSize(fieldNumber, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); + if (value is Enum) + { + return ComputeEnumSize(fieldNumber, ((IConvertible) value).ToInt32(CultureInfo.InvariantCulture)); + } else + { return ComputeEnumSize(fieldNumber, ((IEnumLite) value).Number); + } default: throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); } @@ -597,10 +639,14 @@ namespace Google.ProtocolBuffers case FieldType.SInt64: return ComputeSInt64SizeNoTag((long) value); case FieldType.Enum: - if (value is System.Enum) - return ComputeEnumSizeNoTag(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); + if (value is Enum) + { + return ComputeEnumSizeNoTag(((IConvertible) value).ToInt32(CultureInfo.InvariantCulture)); + } else + { return ComputeEnumSizeNoTag(((IEnumLite) value).Number); + } default: throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); } diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs index 25fc0eaa..59490df3 100644 --- a/src/ProtocolBuffers/CodedOutputStream.cs +++ b/src/ProtocolBuffers/CodedOutputStream.cs @@ -35,10 +35,9 @@ #endregion using System; +using System.Collections; using System.Collections.Generic; -using System.Globalization; using System.IO; -using System.Runtime.InteropServices; using System.Text; using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.Descriptors; @@ -145,14 +144,22 @@ namespace Google.ProtocolBuffers [CLSCompliant(false)] public void WriteUnknownField(int fieldNumber, WireFormat.WireType wireType, ulong value) { - if(wireType == WireFormat.WireType.Varint) + if (wireType == WireFormat.WireType.Varint) + { WriteUInt64(fieldNumber, null /*not used*/, value); + } else if (wireType == WireFormat.WireType.Fixed32) - WriteFixed32(fieldNumber, null /*not used*/, (uint)value); + { + WriteFixed32(fieldNumber, null /*not used*/, (uint) value); + } else if (wireType == WireFormat.WireType.Fixed64) + { WriteFixed64(fieldNumber, null /*not used*/, value); + } else + { throw InvalidProtocolBufferException.InvalidWireType(); + } } #endregion @@ -164,61 +171,65 @@ namespace Google.ProtocolBuffers switch (fieldType) { case FieldType.String: - WriteString(fieldNumber, fieldName, (string)value); + WriteString(fieldNumber, fieldName, (string) value); break; case FieldType.Message: - WriteMessage(fieldNumber, fieldName, (IMessageLite)value); + WriteMessage(fieldNumber, fieldName, (IMessageLite) value); break; case FieldType.Group: - WriteGroup(fieldNumber, fieldName, (IMessageLite)value); + WriteGroup(fieldNumber, fieldName, (IMessageLite) value); break; case FieldType.Bytes: - WriteBytes(fieldNumber, fieldName, (ByteString)value); + WriteBytes(fieldNumber, fieldName, (ByteString) value); break; case FieldType.Bool: - WriteBool(fieldNumber, fieldName, (bool)value); + WriteBool(fieldNumber, fieldName, (bool) value); break; case FieldType.Enum: - if (value is System.Enum) - WriteEnum(fieldNumber, fieldName, (int)value, null/*not used*/); + if (value is Enum) + { + WriteEnum(fieldNumber, fieldName, (int) value, null /*not used*/); + } else - WriteEnum(fieldNumber, fieldName, ((IEnumLite)value).Number, null/*not used*/); + { + WriteEnum(fieldNumber, fieldName, ((IEnumLite) value).Number, null /*not used*/); + } break; case FieldType.Int32: - WriteInt32(fieldNumber, fieldName, (int)value); + WriteInt32(fieldNumber, fieldName, (int) value); break; case FieldType.Int64: - WriteInt64(fieldNumber, fieldName, (long)value); + WriteInt64(fieldNumber, fieldName, (long) value); break; case FieldType.UInt32: - WriteUInt32(fieldNumber, fieldName, (uint)value); + WriteUInt32(fieldNumber, fieldName, (uint) value); break; case FieldType.UInt64: - WriteUInt64(fieldNumber, fieldName, (ulong)value); + WriteUInt64(fieldNumber, fieldName, (ulong) value); break; case FieldType.SInt32: - WriteSInt32(fieldNumber, fieldName, (int)value); + WriteSInt32(fieldNumber, fieldName, (int) value); break; case FieldType.SInt64: - WriteSInt64(fieldNumber, fieldName, (long)value); + WriteSInt64(fieldNumber, fieldName, (long) value); break; case FieldType.Fixed32: - WriteFixed32(fieldNumber, fieldName, (uint)value); + WriteFixed32(fieldNumber, fieldName, (uint) value); break; case FieldType.Fixed64: - WriteFixed64(fieldNumber, fieldName, (ulong)value); + WriteFixed64(fieldNumber, fieldName, (ulong) value); break; case FieldType.SFixed32: - WriteSFixed32(fieldNumber, fieldName, (int)value); + WriteSFixed32(fieldNumber, fieldName, (int) value); break; case FieldType.SFixed64: - WriteSFixed64(fieldNumber, fieldName, (long)value); + WriteSFixed64(fieldNumber, fieldName, (long) value); break; case FieldType.Double: - WriteDouble(fieldNumber, fieldName, (double)value); + WriteDouble(fieldNumber, fieldName, (double) value); break; case FieldType.Float: - WriteFloat(fieldNumber, fieldName, (float)value); + WriteFloat(fieldNumber, fieldName, (float) value); break; } } @@ -348,7 +359,7 @@ namespace Google.ProtocolBuffers public void WriteBytes(int fieldNumber, string fieldName, ByteString value) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)value.Length); + WriteRawVarint32((uint) value.Length); value.WriteTo(this); } @@ -414,61 +425,65 @@ namespace Google.ProtocolBuffers switch (fieldType) { case FieldType.String: - WriteStringNoTag((string)value); + WriteStringNoTag((string) value); break; case FieldType.Message: - WriteMessageNoTag((IMessageLite)value); + WriteMessageNoTag((IMessageLite) value); break; case FieldType.Group: - WriteGroupNoTag((IMessageLite)value); + WriteGroupNoTag((IMessageLite) value); break; case FieldType.Bytes: - WriteBytesNoTag((ByteString)value); + WriteBytesNoTag((ByteString) value); break; case FieldType.Bool: - WriteBoolNoTag((bool)value); + WriteBoolNoTag((bool) value); break; case FieldType.Enum: - if (value is System.Enum) - WriteEnumNoTag((int)value); + if (value is Enum) + { + WriteEnumNoTag((int) value); + } else - WriteEnumNoTag(((IEnumLite)value).Number); + { + WriteEnumNoTag(((IEnumLite) value).Number); + } break; case FieldType.Int32: - WriteInt32NoTag((int)value); + WriteInt32NoTag((int) value); break; case FieldType.Int64: - WriteInt64NoTag((long)value); + WriteInt64NoTag((long) value); break; case FieldType.UInt32: - WriteUInt32NoTag((uint)value); + WriteUInt32NoTag((uint) value); break; case FieldType.UInt64: - WriteUInt64NoTag((ulong)value); + WriteUInt64NoTag((ulong) value); break; case FieldType.SInt32: - WriteSInt32NoTag((int)value); + WriteSInt32NoTag((int) value); break; case FieldType.SInt64: - WriteSInt64NoTag((long)value); + WriteSInt64NoTag((long) value); break; case FieldType.Fixed32: - WriteFixed32NoTag((uint)value); + WriteFixed32NoTag((uint) value); break; case FieldType.Fixed64: - WriteFixed64NoTag((ulong)value); + WriteFixed64NoTag((ulong) value); break; case FieldType.SFixed32: - WriteSFixed32NoTag((int)value); + WriteSFixed32NoTag((int) value); break; case FieldType.SFixed64: - WriteSFixed64NoTag((long)value); + WriteSFixed64NoTag((long) value); break; case FieldType.Double: - WriteDoubleNoTag((double)value); + WriteDoubleNoTag((double) value); break; case FieldType.Float: - WriteFloatNoTag((float)value); + WriteFloatNoTag((float) value); break; } } @@ -497,7 +512,7 @@ namespace Google.ProtocolBuffers else WriteRawBytes(rawBytes, 0, 8); #else - WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value)); + WriteRawLittleEndian64((ulong) BitConverter.DoubleToInt64Bits(value)); #endif } @@ -508,7 +523,9 @@ namespace Google.ProtocolBuffers { byte[] rawBytes = BitConverter.GetBytes(value); if (!BitConverter.IsLittleEndian) + { ByteArray.Reverse(rawBytes); + } if (limit - position >= 4) { @@ -518,7 +535,9 @@ namespace Google.ProtocolBuffers buffer[position++] = rawBytes[3]; } else + { WriteRawBytes(rawBytes, 0, 4); + } } /// @@ -535,7 +554,7 @@ namespace Google.ProtocolBuffers /// public void WriteInt64NoTag(long value) { - WriteRawVarint64((ulong)value); + WriteRawVarint64((ulong) value); } /// @@ -545,12 +564,12 @@ namespace Google.ProtocolBuffers { if (value >= 0) { - WriteRawVarint32((uint)value); + WriteRawVarint32((uint) value); } else { // Must sign-extend. - WriteRawVarint64((ulong)value); + WriteRawVarint64((ulong) value); } } @@ -577,7 +596,7 @@ namespace Google.ProtocolBuffers /// public void WriteBoolNoTag(bool value) { - WriteRawByte(value ? (byte)1 : (byte)0); + WriteRawByte(value ? (byte) 1 : (byte) 0); } /// @@ -588,7 +607,7 @@ namespace Google.ProtocolBuffers // Optimise the case where we have enough space to write // the string directly to the buffer, which should be common. int length = Encoding.UTF8.GetByteCount(value); - WriteRawVarint32((uint)length); + WriteRawVarint32((uint) length); if (limit - position >= length) { Encoding.UTF8.GetBytes(value, 0, value.Length, buffer, position); @@ -611,13 +630,13 @@ namespace Google.ProtocolBuffers public void WriteMessageNoTag(IMessageLite value) { - WriteRawVarint32((uint)value.SerializedSize); + WriteRawVarint32((uint) value.SerializedSize); value.WriteTo(this); } public void WriteBytesNoTag(ByteString value) { - WriteRawVarint32((uint)value.Length); + WriteRawVarint32((uint) value.Length); value.WriteTo(this); } @@ -629,17 +648,17 @@ namespace Google.ProtocolBuffers public void WriteEnumNoTag(int value) { - WriteRawVarint32((uint)value); + WriteRawVarint32((uint) value); } public void WriteSFixed32NoTag(int value) { - WriteRawLittleEndian32((uint)value); + WriteRawLittleEndian32((uint) value); } public void WriteSFixed64NoTag(long value) { - WriteRawLittleEndian64((ulong)value); + WriteRawLittleEndian64((ulong) value); } public void WriteSInt32NoTag(int value) @@ -656,114 +675,150 @@ namespace Google.ProtocolBuffers #region Write array members - public void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list) + public void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list) { foreach (object element in list) + { WriteField(fieldType, fieldNumber, fieldName, element); + } } public void WriteGroupArray(int fieldNumber, string fieldName, IEnumerable list) where T : IMessageLite { foreach (IMessageLite value in list) + { WriteGroup(fieldNumber, fieldName, value); + } } public void WriteMessageArray(int fieldNumber, string fieldName, IEnumerable list) where T : IMessageLite { foreach (IMessageLite value in list) + { WriteMessage(fieldNumber, fieldName, value); + } } public void WriteStringArray(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteString(fieldNumber, fieldName, value); + } } public void WriteBytesArray(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteBytes(fieldNumber, fieldName, value); + } } public void WriteBoolArray(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteBool(fieldNumber, fieldName, value); + } } public void WriteInt32Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteInt32(fieldNumber, fieldName, value); + } } public void WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteSInt32(fieldNumber, fieldName, value); + } } public void WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteUInt32(fieldNumber, fieldName, value); + } } public void WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteFixed32(fieldNumber, fieldName, value); + } } public void WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteSFixed32(fieldNumber, fieldName, value); + } } public void WriteInt64Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteInt64(fieldNumber, fieldName, value); + } } public void WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteSInt64(fieldNumber, fieldName, value); + } } public void WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteUInt64(fieldNumber, fieldName, value); + } } public void WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteFixed64(fieldNumber, fieldName, value); + } } public void WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteSFixed64(fieldNumber, fieldName, value); + } } public void WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteDouble(fieldNumber, fieldName, value); + } } public void WriteFloatArray(int fieldNumber, string fieldName, IEnumerable list) { foreach (var value in list) + { WriteFloat(fieldNumber, fieldName, value); + } } [CLSCompliant(false)] @@ -772,13 +827,17 @@ namespace Google.ProtocolBuffers { if (list is ICastArray) { - foreach (int value in ((ICastArray)list).CastArray()) + foreach (int value in ((ICastArray) list).CastArray()) + { WriteEnum(fieldNumber, fieldName, value, null /*unused*/); + } } else { foreach (object value in list) + { WriteEnum(fieldNumber, fieldName, (int) value, null /*unused*/); + } } } @@ -786,155 +845,202 @@ namespace Google.ProtocolBuffers #region Write packed array members - public void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list) + public void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list) { int calculatedSize = 0; foreach (object element in list) - calculatedSize += CodedOutputStream.ComputeFieldSizeNoTag(fieldType, element); + { + calculatedSize += ComputeFieldSizeNoTag(fieldType, element); + } WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (object element in list) + { WriteFieldNoTag(fieldType, element); + } } public void WritePackedGroupArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) where T : IMessageLite { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (IMessageLite value in list) + { WriteGroupNoTag(value); + } } - public void WritePackedMessageArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedMessageArray(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) where T : IMessageLite { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (IMessageLite value in list) + { WriteMessageNoTag(value); + } } - public void WritePackedStringArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedStringArray(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteStringNoTag(value); + } } - public void WritePackedBytesArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedBytesArray(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteBytesNoTag(value); + } } public void WritePackedBoolArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteBoolNoTag(value); + } } public void WritePackedInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteInt32NoTag(value); + } } public void WritePackedSInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteSInt32NoTag(value); + } } public void WritePackedUInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteUInt32NoTag(value); + } } - public void WritePackedFixed32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedFixed32Array(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteFixed32NoTag(value); + } } - public void WritePackedSFixed32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedSFixed32Array(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteSFixed32NoTag(value); + } } public void WritePackedInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteInt64NoTag(value); + } } public void WritePackedSInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteSInt64NoTag(value); + } } - public void WritePackedUInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedUInt64Array(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteUInt64NoTag(value); + } } - public void WritePackedFixed64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedFixed64Array(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteFixed64NoTag(value); + } } - public void WritePackedSFixed64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedSFixed64Array(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteSFixed64NoTag(value); + } } - public void WritePackedDoubleArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) + public void WritePackedDoubleArray(int fieldNumber, string fieldName, int calculatedSize, + IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteDoubleNoTag(value); + } } public void WritePackedFloatArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list) { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); foreach (var value in list) + { WriteFloatNoTag(value); + } } [CLSCompliant(false)] @@ -942,16 +1048,20 @@ namespace Google.ProtocolBuffers where T : struct, IComparable, IFormattable, IConvertible { WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); - WriteRawVarint32((uint)calculatedSize); + WriteRawVarint32((uint) calculatedSize); if (list is ICastArray) { - foreach (int value in ((ICastArray)list).CastArray()) + foreach (int value in ((ICastArray) list).CastArray()) + { WriteEnumNoTag(value); + } } else { foreach (object value in list) - WriteEnumNoTag((int)value); + { + WriteEnumNoTag((int) value); + } } } @@ -986,6 +1096,7 @@ namespace Google.ProtocolBuffers } } #endif + /// /// Writes a 32 bit value as a varint. The fast route is taken when /// there's enough buffer space left to whizz through without checking @@ -997,18 +1108,22 @@ namespace Google.ProtocolBuffers #if true while (value > 127 && position < limit) { - buffer[position++] = (byte)((value & 0x7F) | 0x80); + buffer[position++] = (byte) ((value & 0x7F) | 0x80); value >>= 7; } while (value > 127) { - WriteRawByte((byte)((value & 0x7F) | 0x80)); + WriteRawByte((byte) ((value & 0x7F) | 0x80)); value >>= 7; } - if(position < limit) - buffer[position++] = (byte)value; + if (position < limit) + { + buffer[position++] = (byte) value; + } else - WriteRawByte((byte)value); + { + WriteRawByte((byte) value); + } #else if (position + 5 > limit) { @@ -1038,18 +1153,22 @@ namespace Google.ProtocolBuffers #if true while (value > 127 && position < limit) { - buffer[position++] = (byte)((value & 0x7F) | 0x80); + buffer[position++] = (byte) ((value & 0x7F) | 0x80); value >>= 7; } while (value > 127) { - WriteRawByte((byte)((value & 0x7F) | 0x80)); + WriteRawByte((byte) ((value & 0x7F) | 0x80)); value >>= 7; } - if(position < limit) - buffer[position++] = (byte)value; + if (position < limit) + { + buffer[position++] = (byte) value; + } else - WriteRawByte((byte)value); + { + WriteRawByte((byte) value); + } #else while (true) { @@ -1079,10 +1198,10 @@ namespace Google.ProtocolBuffers } else { - buffer[position++] = ((byte)value); - buffer[position++] = ((byte)(value >> 8)); - buffer[position++] = ((byte)(value >> 16)); - buffer[position++] = ((byte)(value >> 24)); + buffer[position++] = ((byte) value); + buffer[position++] = ((byte) (value >> 8)); + buffer[position++] = ((byte) (value >> 16)); + buffer[position++] = ((byte) (value >> 24)); } } @@ -1102,14 +1221,14 @@ namespace Google.ProtocolBuffers } else { - buffer[position++] = ((byte)value); - buffer[position++] = ((byte)(value >> 8)); - buffer[position++] = ((byte)(value >> 16)); - buffer[position++] = ((byte)(value >> 24)); - buffer[position++] = ((byte)(value >> 32)); - buffer[position++] = ((byte)(value >> 40)); - buffer[position++] = ((byte)(value >> 48)); - buffer[position++] = ((byte)(value >> 56)); + buffer[position++] = ((byte) value); + buffer[position++] = ((byte) (value >> 8)); + buffer[position++] = ((byte) (value >> 16)); + buffer[position++] = ((byte) (value >> 24)); + buffer[position++] = ((byte) (value >> 32)); + buffer[position++] = ((byte) (value >> 40)); + buffer[position++] = ((byte) (value >> 48)); + buffer[position++] = ((byte) (value >> 56)); } } @@ -1177,6 +1296,7 @@ namespace Google.ProtocolBuffers } #endregion + /// /// Encode a 32-bit value with ZigZag encoding. /// diff --git a/src/ProtocolBuffers/Collections/PopsicleList.cs b/src/ProtocolBuffers/Collections/PopsicleList.cs index 48161e82..6cabb448 100644 --- a/src/ProtocolBuffers/Collections/PopsicleList.cs +++ b/src/ProtocolBuffers/Collections/PopsicleList.cs @@ -30,8 +30,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using System; -using System.Collections.Generic; using System.Collections; +using System.Collections.Generic; namespace Google.ProtocolBuffers.Collections { @@ -76,7 +76,14 @@ namespace Google.ProtocolBuffers.Collections public T this[int index] { - get { if (items == null) throw new ArgumentOutOfRangeException(); return items[index]; } + get + { + if (items == null) + { + throw new ArgumentOutOfRangeException(); + } + return items[index]; + } set { ValidateModification(); @@ -104,7 +111,9 @@ namespace Google.ProtocolBuffers.Collections public void CopyTo(T[] array, int arrayIndex) { if (items != null) + { items.CopyTo(array, arrayIndex); + } } public int Count @@ -140,7 +149,9 @@ namespace Google.ProtocolBuffers.Collections throw new NotSupportedException("List is read-only"); } if (items == null) + { items = new List(); + } items.AddRange(collection); } @@ -151,14 +162,18 @@ namespace Google.ProtocolBuffers.Collections throw new NotSupportedException("List is read-only"); } if (items == null) + { items = new List(); + } } IEnumerable ICastArray.CastArray() { if (items == null) + { return new TItemType[0]; - return (TItemType[])(object)items.ToArray(); + } + return (TItemType[]) (object) items.ToArray(); } } } \ No newline at end of file diff --git a/src/ProtocolBuffers/Descriptors/DescriptorPool.cs b/src/ProtocolBuffers/Descriptors/DescriptorPool.cs index 12abafeb..78f6ef1b 100644 --- a/src/ProtocolBuffers/Descriptors/DescriptorPool.cs +++ b/src/ProtocolBuffers/Descriptors/DescriptorPool.cs @@ -29,8 +29,8 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -using System.Collections.Generic; using System; +using System.Collections.Generic; using System.Text; using System.Text.RegularExpressions; diff --git a/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs b/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs index 2922190d..a0b81b69 100644 --- a/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs +++ b/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs @@ -98,6 +98,7 @@ namespace Google.ProtocolBuffers.Descriptors { return FindValueByNumber(number); } + IEnumLite IEnumLiteMap.FindValueByName(string name) { return FindValueByName(name); diff --git a/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs b/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs index 1c1b9be6..55b7fc54 100644 --- a/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs +++ b/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs @@ -31,6 +31,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using System; using System.Collections.Generic; +using System.Reflection; using Google.ProtocolBuffers.Collections; namespace Google.ProtocolBuffers.Descriptors @@ -62,10 +63,7 @@ namespace Google.ProtocolBuffers.Descriptors private static IDictionary MapFieldTypes() { var map = new Dictionary(); - foreach ( - System.Reflection.FieldInfo field in - typeof (FieldType).GetFields(System.Reflection.BindingFlags.Static | - System.Reflection.BindingFlags.Public)) + foreach (FieldInfo field in typeof (FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) { FieldType fieldType = (FieldType) field.GetValue(null); FieldMappingAttribute mapping = diff --git a/src/ProtocolBuffers/DynamicMessage.cs b/src/ProtocolBuffers/DynamicMessage.cs index 22bcdeb7..6235eb5b 100644 --- a/src/ProtocolBuffers/DynamicMessage.cs +++ b/src/ProtocolBuffers/DynamicMessage.cs @@ -264,7 +264,10 @@ namespace Google.ProtocolBuffers get { int size = memoizedSize; - if (size != -1) return size; + if (size != -1) + { + return size; + } size = fields.SerializedSize; if (type.Options.MessageSetWireFormat) diff --git a/src/ProtocolBuffers/EnumLite.cs b/src/ProtocolBuffers/EnumLite.cs index 35223fcd..8ed4d078 100644 --- a/src/ProtocolBuffers/EnumLite.cs +++ b/src/ProtocolBuffers/EnumLite.cs @@ -36,9 +36,6 @@ using System; using System.Collections.Generic; -using System.Globalization; -using System.Reflection; -using System.Text; namespace Google.ProtocolBuffers { @@ -102,16 +99,18 @@ namespace Google.ProtocolBuffers { items = new SortedList(); #if SILVERLIGHT2 - // Silverlight doesn't support Enum.GetValues - // TODO(jonskeet): Validate that this reflection is permitted, e.g. in Windows Phone 7 + // Silverlight doesn't support Enum.GetValues + // TODO(jonskeet): Validate that this reflection is permitted, e.g. in Windows Phone 7 foreach (FieldInfo fi in typeof (TEnum).GetFields(BindingFlags.Static | BindingFlags.Public)) { TEnum evalue = (TEnum) fi.GetValue(null); items.Add(Convert.ToInt32(evalue), new EnumValue(evalue)); } #else - foreach (TEnum evalue in Enum.GetValues(typeof(TEnum))) - items.Add(Convert.ToInt32(evalue), new EnumValue(evalue)); + foreach (TEnum evalue in Enum.GetValues(typeof (TEnum))) + { + items.Add(Convert.ToInt32(evalue), new EnumValue(evalue)); + } #endif } @@ -129,8 +128,10 @@ namespace Google.ProtocolBuffers public IEnumLite FindValueByName(string name) { IEnumLite val; - if(Enum.IsDefined(typeof(TEnum), name)) - return items.TryGetValue((int)Enum.Parse(typeof(TEnum), name, false), out val) ? val : null; + if (Enum.IsDefined(typeof (TEnum), name)) + { + return items.TryGetValue((int) Enum.Parse(typeof (TEnum), name, false), out val) ? val : null; + } return null; } diff --git a/src/ProtocolBuffers/ExtendableBuilderLite.cs b/src/ProtocolBuffers/ExtendableBuilderLite.cs index 27cd3e3b..cdec4fa3 100644 --- a/src/ProtocolBuffers/ExtendableBuilderLite.cs +++ b/src/ProtocolBuffers/ExtendableBuilderLite.cs @@ -142,8 +142,10 @@ namespace Google.ProtocolBuffers int fieldNumber = WireFormat.GetTagFieldNumber(tag); IGeneratedExtensionLite extension = extensionRegistry[DefaultInstanceForType, fieldNumber]; - if (extension == null)//unknown field + if (extension == null) //unknown field + { return input.SkipField(); + } IFieldDescriptorLite field = extension.Descriptor; @@ -153,9 +155,9 @@ namespace Google.ProtocolBuffers { return input.SkipField(); } - WireFormat.WireType expectedType = field.IsPacked - ? WireFormat.WireType.LengthDelimited - : WireFormat.GetWireType(field.FieldType); + WireFormat.WireType expectedType = field.IsPacked + ? WireFormat.WireType.LengthDelimited + : WireFormat.GetWireType(field.FieldType); if (wireType != expectedType) { expectedType = WireFormat.GetWireType(field.FieldType); @@ -164,15 +166,20 @@ namespace Google.ProtocolBuffers //Allowed as of 2.3, this is unpacked data for a packed array } else if (field.IsRepeated && wireType == WireFormat.WireType.LengthDelimited && - (expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 || expectedType == WireFormat.WireType.Fixed64)) + (expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 || + expectedType == WireFormat.WireType.Fixed64)) { //Allowed as of 2.3, this is packed data for an unpacked array } else + { return input.SkipField(); + } } if (!field.IsRepeated && wireType != WireFormat.GetWireType(field.FieldType)) //invalid wire type + { return input.SkipField(); + } switch (field.FieldType) { @@ -185,22 +192,34 @@ namespace Google.ProtocolBuffers IBuilderLite subBuilder = (message ?? extension.MessageDefaultInstance).WeakToBuilder(); if (field.FieldType == FieldType.Group) + { input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); + } else + { input.ReadMessage(subBuilder, extensionRegistry); - + } + extensions[field] = subBuilder.WeakBuild(); } else { List list = new List(); if (field.FieldType == FieldType.Group) - input.ReadGroupArray(tag, fieldName, list, extension.MessageDefaultInstance, extensionRegistry); + { + input.ReadGroupArray(tag, fieldName, list, extension.MessageDefaultInstance, + extensionRegistry); + } else - input.ReadMessageArray(tag, fieldName, list, extension.MessageDefaultInstance, extensionRegistry); + { + input.ReadMessageArray(tag, fieldName, list, extension.MessageDefaultInstance, + extensionRegistry); + } foreach (IMessageLite m in list) + { extensions.AddRepeatedField(field, m); + } return true; } break; @@ -212,7 +231,9 @@ namespace Google.ProtocolBuffers object unknown; IEnumLite value = null; if (input.ReadEnum(ref value, out unknown, field.EnumType)) + { extensions[field] = value; + } } else { @@ -221,7 +242,9 @@ namespace Google.ProtocolBuffers input.ReadEnumArray(tag, fieldName, list, out unknown, field.EnumType); foreach (IEnumLite en in list) + { extensions.AddRepeatedField(field, en); + } } break; } @@ -231,14 +254,18 @@ namespace Google.ProtocolBuffers { object value = null; if (input.ReadPrimitiveField(field.FieldType, ref value)) + { extensions[field] = value; + } } else { List list = new List(); input.ReadPrimitiveArray(field.FieldType, tag, fieldName, list); foreach (object oval in list) + { extensions.AddRepeatedField(field, oval); + } } break; } diff --git a/src/ProtocolBuffers/ExtendableMessageLite.cs b/src/ProtocolBuffers/ExtendableMessageLite.cs index 3417f152..6ff56566 100644 --- a/src/ProtocolBuffers/ExtendableMessageLite.cs +++ b/src/ProtocolBuffers/ExtendableMessageLite.cs @@ -37,6 +37,7 @@ using System; using System.Collections; using System.Collections.Generic; +using System.IO; using Google.ProtocolBuffers.Collections; namespace Google.ProtocolBuffers @@ -74,7 +75,7 @@ namespace Google.ProtocolBuffers /// /// writes the extensions to the text stream /// - public override void PrintTo(System.IO.TextWriter writer) + public override void PrintTo(TextWriter writer) { foreach (KeyValuePair entry in extensions.AllFields) { @@ -82,7 +83,9 @@ namespace Google.ProtocolBuffers if (entry.Key.IsRepeated) { foreach (object o in ((IEnumerable) entry.Value)) + { PrintField(fn, true, o, writer); + } } else { diff --git a/src/ProtocolBuffers/ExtensionRegistry.cs b/src/ProtocolBuffers/ExtensionRegistry.cs index 98f2fb4d..7c9467b5 100644 --- a/src/ProtocolBuffers/ExtensionRegistry.cs +++ b/src/ProtocolBuffers/ExtensionRegistry.cs @@ -34,9 +34,9 @@ #endregion +using System; using System.Collections.Generic; using Google.ProtocolBuffers.Descriptors; -using System; namespace Google.ProtocolBuffers { @@ -107,7 +107,9 @@ namespace Google.ProtocolBuffers foreach (IGeneratedExtensionLite ext in extensionsByNumber.Values) { if (StringComparer.Ordinal.Equals(ext.Descriptor.FullName, fullName)) + { return ext as ExtensionInfo; + } } return null; } @@ -204,7 +206,9 @@ namespace Google.ProtocolBuffers // up by type name. Dictionary map; if (extensionsByName.TryGetValue(liteExtension.ContainingType, out map)) + { map[field.MessageType.FullName] = extension; + } } } } diff --git a/src/ProtocolBuffers/ExtensionRegistryLite.cs b/src/ProtocolBuffers/ExtensionRegistryLite.cs index 91a0ce29..df0a7b25 100644 --- a/src/ProtocolBuffers/ExtensionRegistryLite.cs +++ b/src/ProtocolBuffers/ExtensionRegistryLite.cs @@ -34,9 +34,8 @@ #endregion -using System.Collections.Generic; using System; -using Google.ProtocolBuffers.Descriptors; +using System.Collections.Generic; namespace Google.ProtocolBuffers { @@ -93,8 +92,13 @@ namespace Google.ProtocolBuffers /// public sealed partial class ExtensionRegistry { - class ExtensionByNameMap : Dictionary> { } - class ExtensionByIdMap : Dictionary { } + private class ExtensionByNameMap : Dictionary> + { + } + + private class ExtensionByIdMap : Dictionary + { + } private static readonly ExtensionRegistry empty = new ExtensionRegistry( new ExtensionByNameMap(), @@ -149,14 +153,18 @@ namespace Google.ProtocolBuffers } public IGeneratedExtensionLite FindByName(IMessageLite defaultInstanceOfType, string fieldName) - { return FindExtensionByName(defaultInstanceOfType, fieldName); } + { + return FindExtensionByName(defaultInstanceOfType, fieldName); + } - IGeneratedExtensionLite FindExtensionByName(object forwhat, string fieldName) + private IGeneratedExtensionLite FindExtensionByName(object forwhat, string fieldName) { IGeneratedExtensionLite extension = null; Dictionary map; if (extensionsByName.TryGetValue(forwhat, out map) && map.TryGetValue(fieldName, out extension)) + { return extension; + } return null; } @@ -173,7 +181,9 @@ namespace Google.ProtocolBuffers Dictionary map; if (!extensionsByName.TryGetValue(extension.ContainingType, out map)) + { extensionsByName.Add(extension.ContainingType, map = new Dictionary()); + } map[extension.Descriptor.Name] = extension; map[extension.Descriptor.FullName] = extension; } @@ -195,7 +205,7 @@ namespace Google.ProtocolBuffers public override int GetHashCode() { - return msgType.GetHashCode() * ((1 << 16) - 1) + number; + return msgType.GetHashCode()*((1 << 16) - 1) + number; } public override bool Equals(object obj) @@ -204,7 +214,7 @@ namespace Google.ProtocolBuffers { return false; } - return Equals((ExtensionIntPair)obj); + return Equals((ExtensionIntPair) obj); } public bool Equals(ExtensionIntPair other) diff --git a/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs b/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs index 25239da5..26d4a5b3 100644 --- a/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs +++ b/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs @@ -62,7 +62,10 @@ namespace Google.ProtocolBuffers.FieldAccess { PropertyInfo messageProperty = typeof (TMessage).GetProperty(name); PropertyInfo builderProperty = typeof (TBuilder).GetProperty(name); - if (builderProperty == null) builderProperty = typeof (TBuilder).GetProperty(name); + if (builderProperty == null) + { + builderProperty = typeof (TBuilder).GetProperty(name); + } PropertyInfo hasProperty = typeof (TMessage).GetProperty("Has" + name); MethodInfo clearMethod = typeof (TBuilder).GetMethod("Clear" + name, EmptyTypes); if (messageProperty == null || builderProperty == null || hasProperty == null || clearMethod == null) diff --git a/src/ProtocolBuffers/FieldSet.cs b/src/ProtocolBuffers/FieldSet.cs index 18e57662..f3c08cf5 100644 --- a/src/ProtocolBuffers/FieldSet.cs +++ b/src/ProtocolBuffers/FieldSet.cs @@ -144,17 +144,19 @@ namespace Google.ProtocolBuffers } #if !LITE - /// - /// Force coercion to full descriptor dictionary. - /// - internal IDictionary AllFieldDescriptors + /// + /// Force coercion to full descriptor dictionary. + /// + internal IDictionary AllFieldDescriptors { get { - SortedList copy = - new SortedList(); + SortedList copy = + new SortedList(); foreach (KeyValuePair fd in fields) - copy.Add((Descriptors.FieldDescriptor) fd.Key, fd.Value); + { + copy.Add((FieldDescriptor) fd.Key, fd.Value); + } return Dictionaries.AsReadOnly(copy); } } @@ -390,13 +392,15 @@ namespace Google.ProtocolBuffers } #if !LITE - /// - /// See - /// + /// + /// See + /// public void MergeFrom(IMessage other) { - foreach (KeyValuePair fd in other.AllFields) + foreach (KeyValuePair fd in other.AllFields) + { MergeField(fd.Key, fd.Value); + } } #endif @@ -470,7 +474,7 @@ namespace Google.ProtocolBuffers { if (field.IsExtension && field.MessageSetWireFormat) { - output.WriteMessageSetExtension(field.FieldNumber, field.Name, (IMessageLite)value); + output.WriteMessageSetExtension(field.FieldNumber, field.Name, (IMessageLite) value); } else { @@ -478,30 +482,13 @@ namespace Google.ProtocolBuffers { IEnumerable valueList = (IEnumerable) value; if (field.IsPacked) + { output.WritePackedArray(field.FieldType, field.FieldNumber, field.Name, valueList); - //{ - // output.WriteTag(field.FieldNumber, WireFormat.WireType.LengthDelimited); - // // Compute the total data size so the length can be written. - // int dataSize = 0; - // foreach (object element in valueList) - // { - // dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element); - // } - // output.WriteRawVarint32((uint) dataSize); - // // Write the data itself, without any tags. - // foreach (object element in valueList) - // { - // output.WriteFieldNoTag(field.FieldType, element); - // } - //} + } else + { output.WriteArray(field.FieldType, field.FieldNumber, field.Name, valueList); - //{ - // foreach (object element in valueList) - // { - // output.WriteField(field.FieldType, field.FieldNumber, field.Name, element); - // } - //} + } } else { @@ -629,8 +616,8 @@ namespace Google.ProtocolBuffers // field name and other useful info in the exception. string message = "Wrong object type used with protocol message reflection."; #if !LITE - Google.ProtocolBuffers.Descriptors.FieldDescriptor fieldinfo = - field as Google.ProtocolBuffers.Descriptors.FieldDescriptor; + FieldDescriptor fieldinfo = + field as FieldDescriptor; if (fieldinfo != null) { message += "Message type \"" + fieldinfo.ContainingType.FullName; diff --git a/src/ProtocolBuffers/GeneratedBuilderLite.cs b/src/ProtocolBuffers/GeneratedBuilderLite.cs index b916a8b0..cd2b8395 100644 --- a/src/ProtocolBuffers/GeneratedBuilderLite.cs +++ b/src/ProtocolBuffers/GeneratedBuilderLite.cs @@ -35,7 +35,6 @@ #endregion using System; -using System.Collections; using System.Collections.Generic; namespace Google.ProtocolBuffers diff --git a/src/ProtocolBuffers/GeneratedExtensionLite.cs b/src/ProtocolBuffers/GeneratedExtensionLite.cs index 393b6d43..a1623348 100644 --- a/src/ProtocolBuffers/GeneratedExtensionLite.cs +++ b/src/ProtocolBuffers/GeneratedExtensionLite.cs @@ -34,10 +34,8 @@ #endregion -using System; using System.Collections; using System.Collections.Generic; -using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.Descriptors; namespace Google.ProtocolBuffers @@ -76,12 +74,14 @@ namespace Google.ProtocolBuffers public string Name { - get + get { string name = fullName; int offset = name.LastIndexOf('.'); if (offset >= 0) + { name = name.Substring(offset); + } return name; } } diff --git a/src/ProtocolBuffers/GeneratedMessage.cs b/src/ProtocolBuffers/GeneratedMessage.cs index d030a17f..8147a88b 100644 --- a/src/ProtocolBuffers/GeneratedMessage.cs +++ b/src/ProtocolBuffers/GeneratedMessage.cs @@ -35,11 +35,14 @@ #endregion using System; +using System.Collections; using System.Collections.Generic; +using System.IO; +using System.Xml; using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.FieldAccess; -using System.Collections; +using Google.ProtocolBuffers.Serialization; namespace Google.ProtocolBuffers { @@ -178,30 +181,37 @@ namespace Google.ProtocolBuffers public static TMessage ParseFromJson(string jsonText) { - return Serialization.JsonFormatReader.CreateInstance(jsonText) + return JsonFormatReader.CreateInstance(jsonText) .Merge(new TBuilder()) .Build(); } - public static TMessage ParseFromJson(System.IO.TextReader reader) - { return ParseFromJson(reader, ExtensionRegistry.Empty); } + public static TMessage ParseFromJson(TextReader reader) + { + return ParseFromJson(reader, ExtensionRegistry.Empty); + } - public static TMessage ParseFromJson(System.IO.TextReader reader, ExtensionRegistry extensionRegistry) + public static TMessage ParseFromJson(TextReader reader, ExtensionRegistry extensionRegistry) { - return Serialization.JsonFormatReader.CreateInstance(reader) + return JsonFormatReader.CreateInstance(reader) .Merge(new TBuilder(), extensionRegistry) .Build(); } - public static TMessage ParseFromXml(System.Xml.XmlReader reader) - { return ParseFromXml(Serialization.XmlFormatReader.DefaultRootElementName, reader, ExtensionRegistry.Empty); } - - public static TMessage ParseFromXml(string rootElementName, System.Xml.XmlReader reader) - { return ParseFromXml(rootElementName, reader, ExtensionRegistry.Empty); } + public static TMessage ParseFromXml(XmlReader reader) + { + return ParseFromXml(XmlFormatReader.DefaultRootElementName, reader, ExtensionRegistry.Empty); + } + + public static TMessage ParseFromXml(string rootElementName, XmlReader reader) + { + return ParseFromXml(rootElementName, reader, ExtensionRegistry.Empty); + } - public static TMessage ParseFromXml(string rootElementName, System.Xml.XmlReader reader, ExtensionRegistry extensionRegistry) + public static TMessage ParseFromXml(string rootElementName, XmlReader reader, + ExtensionRegistry extensionRegistry) { - return Serialization.XmlFormatReader.CreateInstance(reader) + return XmlFormatReader.CreateInstance(reader) .Merge(rootElementName, new TBuilder(), extensionRegistry) .Build(); } diff --git a/src/ProtocolBuffers/GeneratedMessageLite.cs b/src/ProtocolBuffers/GeneratedMessageLite.cs index 2efaeaa8..1406d304 100644 --- a/src/ProtocolBuffers/GeneratedMessageLite.cs +++ b/src/ProtocolBuffers/GeneratedMessageLite.cs @@ -36,9 +36,9 @@ using System; using System.Collections.Generic; -using System.Collections; using System.Globalization; -using Google.ProtocolBuffers.Descriptors; +using System.IO; +using System.Text; namespace Google.ProtocolBuffers { @@ -55,7 +55,7 @@ namespace Google.ProtocolBuffers public override sealed string ToString() { - using (System.IO.StringWriter wtr = new System.IO.StringWriter()) + using (StringWriter wtr = new StringWriter()) { PrintTo(wtr); return wtr.ToString(); @@ -65,18 +65,23 @@ namespace Google.ProtocolBuffers /// /// PrintTo() helper methods for Lite Runtime /// - protected static void PrintField(string name, IList value, System.IO.TextWriter writer) + protected static void PrintField(string name, IList value, TextWriter writer) { foreach (T item in value) + { PrintField(name, true, (object) item, writer); + } } /// /// PrintTo() helper methods for Lite Runtime /// - protected static void PrintField(string name, bool hasValue, object value, System.IO.TextWriter writer) + protected static void PrintField(string name, bool hasValue, object value, TextWriter writer) { - if (!hasValue) return; + if (!hasValue) + { + return; + } if (value is IMessageLite) { writer.WriteLine("{0} {{", name); @@ -87,9 +92,13 @@ namespace Google.ProtocolBuffers { writer.Write("{0}: \"", name); if (value is String) - EscapeBytes(System.Text.Encoding.UTF8.GetBytes((string) value), writer); + { + EscapeBytes(Encoding.UTF8.GetBytes((string) value), writer); + } else + { EscapeBytes(((ByteString) value), writer); + } writer.WriteLine("\""); } else if (value is bool) @@ -116,7 +125,7 @@ namespace Google.ProtocolBuffers /// using 3-digit octal sequences. /// The returned value is guaranteed to be entirely ASCII. /// - private static void EscapeBytes(IEnumerable input, System.IO.TextWriter writer) + private static void EscapeBytes(IEnumerable input, TextWriter writer) { foreach (byte b in input) { diff --git a/src/ProtocolBuffers/GeneratedRepeatExtension.cs b/src/ProtocolBuffers/GeneratedRepeatExtension.cs index 6ea07fc0..a044bf2e 100644 --- a/src/ProtocolBuffers/GeneratedRepeatExtension.cs +++ b/src/ProtocolBuffers/GeneratedRepeatExtension.cs @@ -35,9 +35,9 @@ #endregion using System; +using System.Collections; using System.Collections.Generic; using Google.ProtocolBuffers.Descriptors; -using System.Collections; namespace Google.ProtocolBuffers { diff --git a/src/ProtocolBuffers/IBuilderLite.cs b/src/ProtocolBuffers/IBuilderLite.cs index 3cef895c..801f8e24 100644 --- a/src/ProtocolBuffers/IBuilderLite.cs +++ b/src/ProtocolBuffers/IBuilderLite.cs @@ -34,8 +34,6 @@ #endregion -using System; -using System.Collections.Generic; using System.IO; namespace Google.ProtocolBuffers diff --git a/src/ProtocolBuffers/ICodedInputStream.cs b/src/ProtocolBuffers/ICodedInputStream.cs index e6b168fc..683968ee 100644 --- a/src/ProtocolBuffers/ICodedInputStream.cs +++ b/src/ProtocolBuffers/ICodedInputStream.cs @@ -115,7 +115,7 @@ namespace Google.ProtocolBuffers /// Reads a group field value from the stream. /// void ReadGroup(int fieldNumber, IBuilderLite builder, - ExtensionRegistry extensionRegistry); + ExtensionRegistry extensionRegistry); /// /// Reads a group field value from the stream and merges it into the given @@ -187,7 +187,8 @@ namespace Google.ProtocolBuffers /// read a packed array. /// [CLSCompliant(false)] - void ReadEnumArray(uint fieldTag, string fieldName, ICollection list, out ICollection unknown, IEnumLiteMap mapping); + void ReadEnumArray(uint fieldTag, string fieldName, ICollection list, out ICollection unknown, + IEnumLiteMap mapping); /// /// Reads an array of primitive values into the list, if the wire-type of fieldTag is length-prefixed, it will @@ -202,13 +203,15 @@ namespace Google.ProtocolBuffers /// the most derived type, it is only the type specifier for the collection. /// [CLSCompliant(false)] - void ReadMessageArray(uint fieldTag, string fieldName, ICollection list, T messageType, ExtensionRegistry registry) where T : IMessageLite; + void ReadMessageArray(uint fieldTag, string fieldName, ICollection list, T messageType, + ExtensionRegistry registry) where T : IMessageLite; /// /// Reads a set of messages using the as a template. /// [CLSCompliant(false)] - void ReadGroupArray(uint fieldTag, string fieldName, ICollection list, T messageType, ExtensionRegistry registry) where T : IMessageLite; + void ReadGroupArray(uint fieldTag, string fieldName, ICollection list, T messageType, + ExtensionRegistry registry) where T : IMessageLite; /// /// Reads a field of any primitive type. Enums, groups and embedded diff --git a/src/ProtocolBuffers/ICodedOutputStream.cs b/src/ProtocolBuffers/ICodedOutputStream.cs index d197fa55..df8ca107 100644 --- a/src/ProtocolBuffers/ICodedOutputStream.cs +++ b/src/ProtocolBuffers/ICodedOutputStream.cs @@ -35,6 +35,7 @@ #endregion using System; +using System.Collections; using System.Collections.Generic; using Google.ProtocolBuffers.Descriptors; @@ -49,7 +50,9 @@ namespace Google.ProtocolBuffers [Obsolete] void WriteUnknownGroup(int fieldNumber, IMessageLite value); + void WriteUnknownBytes(int fieldNumber, ByteString value); + [CLSCompliant(false)] void WriteUnknownField(int fieldNumber, WireFormat.WireType wireType, ulong value); @@ -115,6 +118,7 @@ namespace Google.ProtocolBuffers /// Writes a message field value, including tag, to the stream. /// void WriteMessage(int fieldNumber, string fieldName, IMessageLite value); + /// /// Writes a byte array field value, including tag, to the stream. /// @@ -130,67 +134,71 @@ namespace Google.ProtocolBuffers /// Writes an enum field value, including tag, to the stream. /// void WriteEnum(int fieldNumber, string fieldName, int value, object rawValue); + /// /// Writes a fixed 32-bit field value, including tag, to the stream. /// void WriteSFixed32(int fieldNumber, string fieldName, int value); + /// /// Writes a signed fixed 64-bit field value, including tag, to the stream. /// void WriteSFixed64(int fieldNumber, string fieldName, long value); + /// /// Writes a signed 32-bit field value, including tag, to the stream. /// void WriteSInt32(int fieldNumber, string fieldName, int value); + /// /// Writes a signed 64-bit field value, including tag, to the stream. /// void WriteSInt64(int fieldNumber, string fieldName, long value); - void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list); + void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list); void WriteGroupArray(int fieldNumber, string fieldName, IEnumerable list) where T : IMessageLite; - + void WriteMessageArray(int fieldNumber, string fieldName, IEnumerable list) where T : IMessageLite; - + void WriteStringArray(int fieldNumber, string fieldName, IEnumerable list); - + void WriteBytesArray(int fieldNumber, string fieldName, IEnumerable list); - + void WriteBoolArray(int fieldNumber, string fieldName, IEnumerable list); - + void WriteInt32Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteInt64Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable list); - + void WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable list); void WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable list); - + void WriteFloatArray(int fieldNumber, string fieldName, IEnumerable list); [CLSCompliant(false)] - void WriteEnumArray(int fieldNumber, string fieldName, IEnumerable list) + void WriteEnumArray(int fieldNumber, string fieldName, IEnumerable list) where T : struct, IComparable, IFormattable, IConvertible; - void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list); - + void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list); + void WritePackedBoolArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list); void WritePackedInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable list); diff --git a/src/ProtocolBuffers/IMessageLite.cs b/src/ProtocolBuffers/IMessageLite.cs index 62d325cc..90fb9509 100644 --- a/src/ProtocolBuffers/IMessageLite.cs +++ b/src/ProtocolBuffers/IMessageLite.cs @@ -34,8 +34,6 @@ #endregion -using System; -using System.Collections.Generic; using System.IO; namespace Google.ProtocolBuffers diff --git a/src/ProtocolBuffers/IRpcDispatch.cs b/src/ProtocolBuffers/IRpcDispatch.cs index 0583d472..1da5c806 100644 --- a/src/ProtocolBuffers/IRpcDispatch.cs +++ b/src/ProtocolBuffers/IRpcDispatch.cs @@ -34,8 +34,6 @@ #endregion -using System; - namespace Google.ProtocolBuffers { /// diff --git a/src/ProtocolBuffers/MessageStreamIterator.cs b/src/ProtocolBuffers/MessageStreamIterator.cs index 9b266fa4..3c46537d 100644 --- a/src/ProtocolBuffers/MessageStreamIterator.cs +++ b/src/ProtocolBuffers/MessageStreamIterator.cs @@ -35,8 +35,8 @@ #endregion using System; -using System.Collections.Generic; using System.Collections; +using System.Collections.Generic; using System.IO; using System.Reflection; @@ -223,9 +223,13 @@ namespace Google.ProtocolBuffers while (input.ReadTag(out tag, out name)) { if ((tag == 0 && name == "item") || (tag == ExpectedTag)) + { yield return messageReader(input, extensionRegistry); + } else + { throw InvalidProtocolBufferException.InvalidMessageStreamTag(); + } input.ResetSizeCounter(); } diff --git a/src/ProtocolBuffers/NameHelpers.cs b/src/ProtocolBuffers/NameHelpers.cs index 663cfe2d..cd8f2a79 100644 --- a/src/ProtocolBuffers/NameHelpers.cs +++ b/src/ProtocolBuffers/NameHelpers.cs @@ -34,8 +34,8 @@ #endregion -using System.Text; using System.Globalization; +using System.Text; namespace Google.ProtocolBuffers { diff --git a/src/ProtocolBuffers/Serialization/AbstractReader.cs b/src/ProtocolBuffers/Serialization/AbstractReader.cs index 3aa54e8f..bc1fa6cd 100644 --- a/src/ProtocolBuffers/Serialization/AbstractReader.cs +++ b/src/ProtocolBuffers/Serialization/AbstractReader.cs @@ -12,19 +12,22 @@ namespace Google.ProtocolBuffers.Serialization /// public abstract class AbstractReader : ICodedInputStream { - const int MaxDepth = CodedInputStream.DefaultRecursionLimit; + private const int MaxDepth = CodedInputStream.DefaultRecursionLimit; protected int Depth; /// /// Merges the contents of stream into the provided message builder /// public TBuilder Merge(TBuilder builder) where TBuilder : IBuilderLite - { return Merge(builder, ExtensionRegistry.Empty); } + { + return Merge(builder, ExtensionRegistry.Empty); + } /// /// Merges the contents of stream into the provided message builder /// - public abstract TBuilder Merge(TBuilder builder, ExtensionRegistry registry) where TBuilder : IBuilderLite; + public abstract TBuilder Merge(TBuilder builder, ExtensionRegistry registry) + where TBuilder : IBuilderLite; /// /// Peeks at the next field in the input stream and returns what information is available. @@ -117,14 +120,17 @@ namespace Google.ProtocolBuffers.Serialization yield return next; if (!PeekNext(out next) || next != field) + { break; + } } } /// /// Reads an array of T messages /// - public virtual bool ReadMessageArray(string field, ICollection items, IMessageLite messageType, ExtensionRegistry registry) + public virtual bool ReadMessageArray(string field, ICollection items, IMessageLite messageType, + ExtensionRegistry registry) { bool success = false; foreach (string next in ForeachArrayItem(field)) @@ -132,7 +138,7 @@ namespace Google.ProtocolBuffers.Serialization IBuilderLite builder = messageType.WeakCreateBuilderForType(); if (ReadMessage(builder, registry)) { - items.Add((T)builder.WeakBuild()); + items.Add((T) builder.WeakBuild()); success |= true; } } @@ -142,7 +148,8 @@ namespace Google.ProtocolBuffers.Serialization /// /// Reads an array of T messages as a proto-buffer group /// - public virtual bool ReadGroupArray(string field, ICollection items, IMessageLite messageType, ExtensionRegistry registry) + public virtual bool ReadGroupArray(string field, ICollection items, IMessageLite messageType, + ExtensionRegistry registry) { bool success = false; foreach (string next in ForeachArrayItem(field)) @@ -150,7 +157,7 @@ namespace Google.ProtocolBuffers.Serialization IBuilderLite builder = messageType.WeakCreateBuilderForType(); if (ReadGroup(builder, registry)) { - items.Add((T)builder.WeakBuild()); + items.Add((T) builder.WeakBuild()); success |= true; } } @@ -186,7 +193,7 @@ namespace Google.ProtocolBuffers.Serialization object temp = null; if (ReadField(type, ref temp)) { - items.Add((T)temp); + items.Add((T) temp); success |= true; } } @@ -204,9 +211,13 @@ namespace Google.ProtocolBuffers.Serialization { bool temp = false; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.Int64: @@ -215,9 +226,13 @@ namespace Google.ProtocolBuffers.Serialization { long temp = 0; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.UInt64: @@ -225,9 +240,13 @@ namespace Google.ProtocolBuffers.Serialization { ulong temp = 0; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.Int32: @@ -236,9 +255,13 @@ namespace Google.ProtocolBuffers.Serialization { int temp = 0; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.UInt32: @@ -246,45 +269,65 @@ namespace Google.ProtocolBuffers.Serialization { uint temp = 0; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.Float: { float temp = float.NaN; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.Double: { double temp = float.NaN; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.String: { string temp = null; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } case FieldType.Bytes: { ByteString temp = null; if (Read(ref temp)) + { value = temp; + } else + { return false; + } break; } default: @@ -306,65 +349,99 @@ namespace Google.ProtocolBuffers.Serialization } bool ICodedInputStream.ReadDouble(ref double value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadFloat(ref float value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadUInt64(ref ulong value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadInt64(ref long value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadInt32(ref int value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadFixed64(ref ulong value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadFixed32(ref uint value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadBool(ref bool value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadString(ref string value) - { return Read(ref value); } + { + return Read(ref value); + } void ICodedInputStream.ReadGroup(int fieldNumber, IBuilderLite builder, ExtensionRegistry extensionRegistry) { if (Depth++ > MaxDepth) + { throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } ReadGroup(builder, extensionRegistry); Depth--; } void ICodedInputStream.ReadUnknownGroup(int fieldNumber, IBuilderLite builder) - { throw new NotSupportedException(); } + { + throw new NotSupportedException(); + } void ICodedInputStream.ReadMessage(IBuilderLite builder, ExtensionRegistry extensionRegistry) { if (Depth++ > MaxDepth) - throw InvalidProtocolBufferException.RecursionLimitExceeded(); + { + throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } ReadMessage(builder, extensionRegistry); Depth--; } bool ICodedInputStream.ReadBytes(ref ByteString value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadUInt32(ref uint value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadEnum(ref IEnumLite value, out object unknown, IEnumLiteMap mapping) { value = null; unknown = null; - if(ReadEnum(ref unknown)) + if (ReadEnum(ref unknown)) { - if (unknown is int) value = mapping.FindValueByNumber((int)unknown); - else if (unknown is string) value = mapping.FindValueByName((string)unknown); + if (unknown is int) + { + value = mapping.FindValueByNumber((int) unknown); + } + else if (unknown is string) + { + value = mapping.FindValueByName((string) unknown); + } return value != null; } return false; @@ -375,12 +452,16 @@ namespace Google.ProtocolBuffers.Serialization rawValue = null; if (ReadEnum(ref rawValue)) { - if (Enum.IsDefined(typeof(T), rawValue)) + if (Enum.IsDefined(typeof (T), rawValue)) { if (rawValue is int) - value = (T)rawValue; + { + value = (T) rawValue; + } else if (rawValue is string) - value = (T)Enum.Parse(typeof(T), (string)rawValue, false); + { + value = (T) Enum.Parse(typeof (T), (string) rawValue, false); + } else { value = default(T); @@ -393,21 +474,33 @@ namespace Google.ProtocolBuffers.Serialization } bool ICodedInputStream.ReadSFixed32(ref int value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadSFixed64(ref long value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadSInt32(ref int value) - { return Read(ref value); } + { + return Read(ref value); + } bool ICodedInputStream.ReadSInt64(ref long value) - { return Read(ref value); } + { + return Read(ref value); + } - void ICodedInputStream.ReadPrimitiveArray(FieldType fieldType, uint fieldTag, string fieldName, ICollection list) - { ReadArray(fieldType, fieldName, list); } + void ICodedInputStream.ReadPrimitiveArray(FieldType fieldType, uint fieldTag, string fieldName, + ICollection list) + { + ReadArray(fieldType, fieldName, list); + } - void ICodedInputStream.ReadEnumArray(uint fieldTag, string fieldName, ICollection list, out ICollection unknown, IEnumLiteMap mapping) + void ICodedInputStream.ReadEnumArray(uint fieldTag, string fieldName, ICollection list, + out ICollection unknown, IEnumLiteMap mapping) { unknown = null; List array = new List(); @@ -416,21 +509,33 @@ namespace Google.ProtocolBuffers.Serialization foreach (object rawValue in array) { IEnumLite item = null; - if (rawValue is int) item = mapping.FindValueByNumber((int)rawValue); - else if (rawValue is string) item = mapping.FindValueByName((string)rawValue); + if (rawValue is int) + { + item = mapping.FindValueByNumber((int) rawValue); + } + else if (rawValue is string) + { + item = mapping.FindValueByName((string) rawValue); + } if (item != null) + { list.Add(item); + } else { - if (unknown == null) unknown = new List(); + if (unknown == null) + { + unknown = new List(); + } unknown.Add(rawValue); } } } } - void ICodedInputStream.ReadEnumArray(uint fieldTag, string fieldName, ICollection list, out ICollection unknown) + void ICodedInputStream.ReadEnumArray(uint fieldTag, string fieldName, ICollection list, + out ICollection unknown) { unknown = null; List array = new List(); @@ -439,40 +544,59 @@ namespace Google.ProtocolBuffers.Serialization foreach (object rawValue in array) { if (rawValue is int) - list.Add((T)rawValue); + { + list.Add((T) rawValue); + } else if (rawValue is string) - list.Add((T)Enum.Parse(typeof(T), (string)rawValue, false)); + { + list.Add((T) Enum.Parse(typeof (T), (string) rawValue, false)); + } else { - if (unknown == null) unknown = new List(); + if (unknown == null) + { + unknown = new List(); + } unknown.Add(rawValue); } } } } - void ICodedInputStream.ReadMessageArray(uint fieldTag, string fieldName, ICollection list, T messageType, ExtensionRegistry registry) + void ICodedInputStream.ReadMessageArray(uint fieldTag, string fieldName, ICollection list, T messageType, + ExtensionRegistry registry) { if (Depth++ > MaxDepth) - throw InvalidProtocolBufferException.RecursionLimitExceeded(); + { + throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } ReadMessageArray(fieldName, list, messageType, registry); Depth--; } - void ICodedInputStream.ReadGroupArray(uint fieldTag, string fieldName, ICollection list, T messageType, ExtensionRegistry registry) + void ICodedInputStream.ReadGroupArray(uint fieldTag, string fieldName, ICollection list, T messageType, + ExtensionRegistry registry) { if (Depth++ > MaxDepth) + { throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } ReadGroupArray(fieldName, list, messageType, registry); Depth--; } bool ICodedInputStream.ReadPrimitiveField(FieldType fieldType, ref object value) - { return ReadField(fieldType, ref value); } + { + return ReadField(fieldType, ref value); + } bool ICodedInputStream.IsAtEnd { - get { string next; return PeekNext(out next) == false; } + get + { + string next; + return PeekNext(out next) == false; + } } bool ICodedInputStream.SkipField() @@ -482,50 +606,80 @@ namespace Google.ProtocolBuffers.Serialization } void ICodedInputStream.ReadStringArray(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.String, fieldName, list); } + { + ReadArray(FieldType.String, fieldName, list); + } void ICodedInputStream.ReadBytesArray(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Bytes, fieldName, list); } + { + ReadArray(FieldType.Bytes, fieldName, list); + } void ICodedInputStream.ReadBoolArray(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Bool, fieldName, list); } + { + ReadArray(FieldType.Bool, fieldName, list); + } void ICodedInputStream.ReadInt32Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Int32, fieldName, list); } + { + ReadArray(FieldType.Int32, fieldName, list); + } void ICodedInputStream.ReadSInt32Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.SInt32, fieldName, list); } + { + ReadArray(FieldType.SInt32, fieldName, list); + } void ICodedInputStream.ReadUInt32Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.UInt32, fieldName, list); } + { + ReadArray(FieldType.UInt32, fieldName, list); + } void ICodedInputStream.ReadFixed32Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Fixed32, fieldName, list); } + { + ReadArray(FieldType.Fixed32, fieldName, list); + } void ICodedInputStream.ReadSFixed32Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.SFixed32, fieldName, list); } + { + ReadArray(FieldType.SFixed32, fieldName, list); + } void ICodedInputStream.ReadInt64Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Int64, fieldName, list); } + { + ReadArray(FieldType.Int64, fieldName, list); + } void ICodedInputStream.ReadSInt64Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.SInt64, fieldName, list); } + { + ReadArray(FieldType.SInt64, fieldName, list); + } void ICodedInputStream.ReadUInt64Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.UInt64, fieldName, list); } + { + ReadArray(FieldType.UInt64, fieldName, list); + } void ICodedInputStream.ReadFixed64Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Fixed64, fieldName, list); } + { + ReadArray(FieldType.Fixed64, fieldName, list); + } void ICodedInputStream.ReadSFixed64Array(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.SFixed64, fieldName, list); } + { + ReadArray(FieldType.SFixed64, fieldName, list); + } void ICodedInputStream.ReadDoubleArray(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Double, fieldName, list); } + { + ReadArray(FieldType.Double, fieldName, list); + } void ICodedInputStream.ReadFloatArray(uint fieldTag, string fieldName, ICollection list) - { ReadArray(FieldType.Float, fieldName, list); } + { + ReadArray(FieldType.Float, fieldName, list); + } #endregion } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/AbstractTextReader.cs b/src/ProtocolBuffers/Serialization/AbstractTextReader.cs index 2f07ac72..83a8dca5 100644 --- a/src/ProtocolBuffers/Serialization/AbstractTextReader.cs +++ b/src/ProtocolBuffers/Serialization/AbstractTextReader.cs @@ -20,7 +20,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref string value) { string text = null; - if (ReadAsText(ref text, typeof(string))) + if (ReadAsText(ref text, typeof (string))) { value = text; return true; @@ -34,7 +34,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref bool value) { string text = null; - if (ReadAsText(ref text, typeof(bool))) + if (ReadAsText(ref text, typeof (bool))) { value = XmlConvert.ToBoolean(text); return true; @@ -48,7 +48,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref int value) { string text = null; - if (ReadAsText(ref text, typeof(int))) + if (ReadAsText(ref text, typeof (int))) { value = XmlConvert.ToInt32(text); return true; @@ -63,7 +63,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref uint value) { string text = null; - if (ReadAsText(ref text, typeof(uint))) + if (ReadAsText(ref text, typeof (uint))) { value = XmlConvert.ToUInt32(text); return true; @@ -77,7 +77,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref long value) { string text = null; - if (ReadAsText(ref text, typeof(long))) + if (ReadAsText(ref text, typeof (long))) { value = XmlConvert.ToInt64(text); return true; @@ -92,7 +92,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref ulong value) { string text = null; - if (ReadAsText(ref text, typeof(ulong))) + if (ReadAsText(ref text, typeof (ulong))) { value = XmlConvert.ToUInt64(text); return true; @@ -106,7 +106,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref float value) { string text = null; - if (ReadAsText(ref text, typeof(float))) + if (ReadAsText(ref text, typeof (float))) { value = XmlConvert.ToSingle(text); return true; @@ -120,7 +120,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref double value) { string text = null; - if (ReadAsText(ref text, typeof(double))) + if (ReadAsText(ref text, typeof (double))) { value = XmlConvert.ToDouble(text); return true; @@ -131,7 +131,10 @@ namespace Google.ProtocolBuffers.Serialization /// /// Provides decoding of bytes read from the input stream /// - protected virtual ByteString DecodeBytes(string bytes) { return ByteString.FromBase64(bytes); } + protected virtual ByteString DecodeBytes(string bytes) + { + return ByteString.FromBase64(bytes); + } /// /// Returns true if it was able to read a ByteString from the input @@ -139,7 +142,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool Read(ref ByteString value) { string text = null; - if (ReadAsText(ref text, typeof(ByteString))) + if (ReadAsText(ref text, typeof (ByteString))) { value = DecodeBytes(text); return true; @@ -154,7 +157,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool ReadEnum(ref object value) { string text = null; - if (ReadAsText(ref text, typeof(Enum))) + if (ReadAsText(ref text, typeof (Enum))) { int number; if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out number)) diff --git a/src/ProtocolBuffers/Serialization/AbstractTextWriter.cs b/src/ProtocolBuffers/Serialization/AbstractTextWriter.cs index 75acc0f4..2c778dfc 100644 --- a/src/ProtocolBuffers/Serialization/AbstractTextWriter.cs +++ b/src/ProtocolBuffers/Serialization/AbstractTextWriter.cs @@ -11,7 +11,10 @@ namespace Google.ProtocolBuffers.Serialization /// /// Encodes raw bytes to be written to the stream /// - protected virtual string EncodeBytes(ByteString bytes) { return bytes.ToBase64(); } + protected virtual string EncodeBytes(ByteString bytes) + { + return bytes.ToBase64(); + } /// /// Writes a typed field as a text value @@ -21,53 +24,83 @@ namespace Google.ProtocolBuffers.Serialization /// /// Writes a String value /// - protected override void Write(string field, string value) { WriteAsText(field, value, value); } + protected override void Write(string field, string value) + { + WriteAsText(field, value, value); + } /// /// Writes a Boolean value /// - protected override void Write(string field, bool value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, bool value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a Int32 value /// - protected override void Write(string field, int value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, int value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a UInt32 value /// [CLSCompliant(false)] - protected override void Write(string field, uint value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, uint value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a Int64 value /// - protected override void Write(string field, long value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, long value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a UInt64 value /// [CLSCompliant(false)] - protected override void Write(string field, ulong value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, ulong value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a Single value /// - protected override void Write(string field, float value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, float value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a Double value /// - protected override void Write(string field, double value) { WriteAsText(field, XmlConvert.ToString(value), value); } + protected override void Write(string field, double value) + { + WriteAsText(field, XmlConvert.ToString(value), value); + } /// /// Writes a set of bytes /// - protected override void Write(string field, ByteString value) { WriteAsText(field, EncodeBytes(value), value); } + protected override void Write(string field, ByteString value) + { + WriteAsText(field, EncodeBytes(value), value); + } /// /// Writes a System.Enum by the numeric and textual value /// - protected override void WriteEnum(string field, int number, string name) { WriteAsText(field, name, number); } + protected override void WriteEnum(string field, int number, string name) + { + WriteAsText(field, name, number); + } } } \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/AbstractWriter.cs b/src/ProtocolBuffers/Serialization/AbstractWriter.cs index 96153162..6592c1dd 100644 --- a/src/ProtocolBuffers/Serialization/AbstractWriter.cs +++ b/src/ProtocolBuffers/Serialization/AbstractWriter.cs @@ -1,5 +1,6 @@ using System; using System.Collections; +using System.Collections.Generic; using System.Globalization; using Google.ProtocolBuffers.Descriptors; @@ -27,7 +28,8 @@ namespace Google.ProtocolBuffers.Serialization /// Completes any pending write operations /// public virtual void Flush() - { } + { + } /// /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. @@ -105,28 +107,60 @@ namespace Google.ProtocolBuffers.Serialization { switch (fieldType) { - case FieldType.Bool: Write(field, (bool)value); break; + case FieldType.Bool: + Write(field, (bool) value); + break; case FieldType.Int64: case FieldType.SInt64: - case FieldType.SFixed64: Write(field, (long)value); break; + case FieldType.SFixed64: + Write(field, (long) value); + break; case FieldType.UInt64: - case FieldType.Fixed64: Write(field, (ulong)value); break; + case FieldType.Fixed64: + Write(field, (ulong) value); + break; case FieldType.Int32: case FieldType.SInt32: - case FieldType.SFixed32: Write(field, (int)value); break; + case FieldType.SFixed32: + Write(field, (int) value); + break; case FieldType.UInt32: - 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; + 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; case FieldType.Enum: { - if (value is IEnumLite) WriteEnum(field, ((IEnumLite)value).Number, ((IEnumLite)value).Name); - else if (value is IConvertible) WriteEnum(field, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture), ((IConvertible)value).ToString(CultureInfo.InvariantCulture)); - else throw new ArgumentException("Expected an Enum type for field " + field); + if (value is IEnumLite) + { + WriteEnum(field, ((IEnumLite) value).Number, ((IEnumLite) value).Name); + } + else if (value is IConvertible) + { + WriteEnum(field, ((IConvertible) value).ToInt32(CultureInfo.InvariantCulture), + ((IConvertible) value).ToString(CultureInfo.InvariantCulture)); + } + else + { + throw new ArgumentException("Expected an Enum type for field " + field); + } break; } default: @@ -140,7 +174,9 @@ namespace Google.ProtocolBuffers.Serialization protected virtual void WriteArray(FieldType fieldType, string field, IEnumerable items) { foreach (object obj in items) + { WriteField(fieldType, field, obj); + } } /// @@ -148,191 +184,321 @@ namespace Google.ProtocolBuffers.Serialization /// [CLSCompliant(false)] protected virtual void WriteUnknown(WireFormat.WireType wireType, int fieldNumber, ulong value) - { } + { + } /// /// Writes an unknown field, Expect WireType of GroupStart or LengthPrefix /// [CLSCompliant(false)] protected virtual void WriteUnknown(WireFormat.WireType wireType, int fieldNumber, ByteString value) - { } + { + } #region ICodedOutputStream Members void ICodedOutputStream.WriteUnknownGroup(int fieldNumber, IMessageLite value) - { } + { + } + void ICodedOutputStream.WriteUnknownBytes(int fieldNumber, ByteString value) - { } + { + } + void ICodedOutputStream.WriteUnknownField(int fieldNumber, WireFormat.WireType type, ulong value) - { } + { + } void ICodedOutputStream.WriteMessageSetExtension(int fieldNumber, string fieldName, IMessageLite value) - { } + { + } void ICodedOutputStream.WriteMessageSetExtension(int fieldNumber, string fieldName, ByteString value) - { } + { + } void ICodedOutputStream.WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value) - { WriteField(fieldType, fieldName, value); } + { + WriteField(fieldType, fieldName, value); + } void ICodedOutputStream.WriteDouble(int fieldNumber, string fieldName, double value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteFloat(int fieldNumber, string fieldName, float value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteUInt64(int fieldNumber, string fieldName, ulong value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteInt64(int fieldNumber, string fieldName, long value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteInt32(int fieldNumber, string fieldName, int value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteFixed64(int fieldNumber, string fieldName, ulong value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteFixed32(int fieldNumber, string fieldName, uint value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteBool(int fieldNumber, string fieldName, bool value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteString(int fieldNumber, string fieldName, string value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteGroup(int fieldNumber, string fieldName, IMessageLite value) - { WriteMessageOrGroup(fieldName, value); } + { + WriteMessageOrGroup(fieldName, value); + } void ICodedOutputStream.WriteMessage(int fieldNumber, string fieldName, IMessageLite value) - { WriteMessageOrGroup(fieldName, value); } + { + WriteMessageOrGroup(fieldName, value); + } void ICodedOutputStream.WriteBytes(int fieldNumber, string fieldName, ByteString value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteUInt32(int fieldNumber, string fieldName, uint value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteEnum(int fieldNumber, string fieldName, int value, object rawValue) - { WriteEnum(fieldName, value, rawValue.ToString()); } + { + WriteEnum(fieldName, value, rawValue.ToString()); + } void ICodedOutputStream.WriteSFixed32(int fieldNumber, string fieldName, int value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteSFixed64(int fieldNumber, string fieldName, long value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteSInt32(int fieldNumber, string fieldName, int value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteSInt64(int fieldNumber, string fieldName, long value) - { Write(fieldName, value); } + { + Write(fieldName, value); + } void ICodedOutputStream.WriteArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list) - { WriteArray(fieldType, fieldName, list); } + { + WriteArray(fieldType, fieldName, list); + } - void ICodedOutputStream.WriteGroupArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Group, fieldName, list); } + void ICodedOutputStream.WriteGroupArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Group, fieldName, list); + } - void ICodedOutputStream.WriteMessageArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Message, fieldName, list); } + void ICodedOutputStream.WriteMessageArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Message, fieldName, list); + } - void ICodedOutputStream.WriteStringArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.String, fieldName, list); } + void ICodedOutputStream.WriteStringArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.String, fieldName, list); + } - void ICodedOutputStream.WriteBytesArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Bytes, fieldName, list); } + void ICodedOutputStream.WriteBytesArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Bytes, fieldName, list); + } - void ICodedOutputStream.WriteBoolArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Bool, fieldName, list); } + void ICodedOutputStream.WriteBoolArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Bool, fieldName, list); + } - void ICodedOutputStream.WriteInt32Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Int32, fieldName, list); } + void ICodedOutputStream.WriteInt32Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Int32, fieldName, list); + } - void ICodedOutputStream.WriteSInt32Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SInt32, fieldName, list); } + void ICodedOutputStream.WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.SInt32, fieldName, list); + } - void ICodedOutputStream.WriteUInt32Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.UInt32, fieldName, list); } + void ICodedOutputStream.WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.UInt32, fieldName, list); + } - void ICodedOutputStream.WriteFixed32Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Fixed32, fieldName, list); } + void ICodedOutputStream.WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Fixed32, fieldName, list); + } - void ICodedOutputStream.WriteSFixed32Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SFixed32, fieldName, list); } + void ICodedOutputStream.WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.SFixed32, fieldName, list); + } - void ICodedOutputStream.WriteInt64Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Int64, fieldName, list); } + void ICodedOutputStream.WriteInt64Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Int64, fieldName, list); + } - void ICodedOutputStream.WriteSInt64Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SInt64, fieldName, list); } + void ICodedOutputStream.WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.SInt64, fieldName, list); + } - void ICodedOutputStream.WriteUInt64Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.UInt64, fieldName, list); } + void ICodedOutputStream.WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.UInt64, fieldName, list); + } - void ICodedOutputStream.WriteFixed64Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Fixed64, fieldName, list); } + void ICodedOutputStream.WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Fixed64, fieldName, list); + } - void ICodedOutputStream.WriteSFixed64Array(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SFixed64, fieldName, list); } + void ICodedOutputStream.WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.SFixed64, fieldName, list); + } - void ICodedOutputStream.WriteDoubleArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Double, fieldName, list); } + void ICodedOutputStream.WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Double, fieldName, list); + } - void ICodedOutputStream.WriteFloatArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Float, fieldName, list); } + void ICodedOutputStream.WriteFloatArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Float, fieldName, list); + } - void ICodedOutputStream.WriteEnumArray(int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Enum, fieldName, list); } + void ICodedOutputStream.WriteEnumArray(int fieldNumber, string fieldName, IEnumerable list) + { + WriteArray(FieldType.Enum, fieldName, list); + } - void ICodedOutputStream.WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, IEnumerable list) - { WriteArray(fieldType, fieldName, list); } + void ICodedOutputStream.WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, + IEnumerable list) + { + WriteArray(fieldType, fieldName, list); + } - void ICodedOutputStream.WritePackedBoolArray(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Bool, fieldName, list); } + void ICodedOutputStream.WritePackedBoolArray(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Bool, fieldName, list); + } - void ICodedOutputStream.WritePackedInt32Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Int32, fieldName, list); } + void ICodedOutputStream.WritePackedInt32Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Int32, fieldName, list); + } - void ICodedOutputStream.WritePackedSInt32Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SInt32, fieldName, list); } + void ICodedOutputStream.WritePackedSInt32Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.SInt32, fieldName, list); + } - void ICodedOutputStream.WritePackedUInt32Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.UInt32, fieldName, list); } + void ICodedOutputStream.WritePackedUInt32Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.UInt32, fieldName, list); + } - void ICodedOutputStream.WritePackedFixed32Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Fixed32, fieldName, list); } + void ICodedOutputStream.WritePackedFixed32Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Fixed32, fieldName, list); + } - void ICodedOutputStream.WritePackedSFixed32Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SFixed32, fieldName, list); } + void ICodedOutputStream.WritePackedSFixed32Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.SFixed32, fieldName, list); + } - void ICodedOutputStream.WritePackedInt64Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Int64, fieldName, list); } + void ICodedOutputStream.WritePackedInt64Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Int64, fieldName, list); + } - void ICodedOutputStream.WritePackedSInt64Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SInt64, fieldName, list); } + void ICodedOutputStream.WritePackedSInt64Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.SInt64, fieldName, list); + } - void ICodedOutputStream.WritePackedUInt64Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.UInt64, fieldName, list); } + void ICodedOutputStream.WritePackedUInt64Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.UInt64, fieldName, list); + } - void ICodedOutputStream.WritePackedFixed64Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Fixed64, fieldName, list); } + void ICodedOutputStream.WritePackedFixed64Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Fixed64, fieldName, list); + } - void ICodedOutputStream.WritePackedSFixed64Array(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.SFixed64, fieldName, list); } + void ICodedOutputStream.WritePackedSFixed64Array(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.SFixed64, fieldName, list); + } - void ICodedOutputStream.WritePackedDoubleArray(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Double, fieldName, list); } + void ICodedOutputStream.WritePackedDoubleArray(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Double, fieldName, list); + } - void ICodedOutputStream.WritePackedFloatArray(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Float, fieldName, list); } + void ICodedOutputStream.WritePackedFloatArray(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Float, fieldName, list); + } - void ICodedOutputStream.WritePackedEnumArray(int fieldNumber, string fieldName, int computedSize, System.Collections.Generic.IEnumerable list) - { WriteArray(FieldType.Enum, fieldName, list); } + void ICodedOutputStream.WritePackedEnumArray(int fieldNumber, string fieldName, int computedSize, + IEnumerable list) + { + WriteArray(FieldType.Enum, fieldName, list); + } #endregion } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/DictionaryReader.cs b/src/ProtocolBuffers/Serialization/DictionaryReader.cs index d6e5c189..70028958 100644 --- a/src/ProtocolBuffers/Serialization/DictionaryReader.cs +++ b/src/ProtocolBuffers/Serialization/DictionaryReader.cs @@ -1,6 +1,6 @@ using System; using System.Collections.Generic; -using System.Text; +using System.Globalization; using Google.ProtocolBuffers.Descriptors; namespace Google.ProtocolBuffers.Serialization @@ -54,23 +54,32 @@ namespace Google.ProtocolBuffers.Serialization private bool GetValue(ref T value) { - if (!_ready) return false; + if (!_ready) + { + return false; + } object obj = _input.Current.Value; if (obj is T) - value = (T)obj; + { + value = (T) obj; + } else { - try + try { if (obj is IConvertible) - value = (T)Convert.ChangeType(obj, typeof(T), System.Globalization.CultureInfo.InvariantCulture); + { + value = (T) Convert.ChangeType(obj, typeof (T), CultureInfo.InvariantCulture); + } else - value = (T)obj; + { + value = (T) obj; + } } catch { - _ready = _input.MoveNext(); + _ready = _input.MoveNext(); return false; } } @@ -83,7 +92,7 @@ namespace Google.ProtocolBuffers.Serialization /// protected override bool Read(ref bool value) { - return GetValue(ref value); + return GetValue(ref value); } /// @@ -186,35 +195,42 @@ namespace Google.ProtocolBuffers.Serialization object[] array = null; if (GetValue(ref array)) { - if (typeof(T) == typeof(ByteString)) + if (typeof (T) == typeof (ByteString)) { - ICollection output = (ICollection)items; + ICollection output = (ICollection) items; foreach (byte[] item in array) + { output.Add(ByteString.CopyFrom(item)); + } } else { foreach (T item in array) + { items.Add(item); + } } return true; } return false; } - + public override bool ReadEnumArray(string field, ICollection items) { object[] array = null; if (GetValue(ref array)) { foreach (object item in array) + { items.Add(item); + } return true; } return false; } - public override bool ReadMessageArray(string field, ICollection items, IMessageLite messageType, ExtensionRegistry registry) + public override bool ReadMessageArray(string field, ICollection items, IMessageLite messageType, + ExtensionRegistry registry) { object[] array = null; if (GetValue(ref array)) @@ -223,14 +239,17 @@ namespace Google.ProtocolBuffers.Serialization { IBuilderLite builder = messageType.WeakCreateBuilderForType(); new DictionaryReader(item).Merge(builder); - items.Add((T)builder.WeakBuild()); + items.Add((T) builder.WeakBuild()); } return true; } return false; } - public override bool ReadGroupArray(string field, ICollection items, IMessageLite messageType, ExtensionRegistry registry) - { return ReadMessageArray(field, items, messageType, registry); } + public override bool ReadGroupArray(string field, ICollection items, IMessageLite messageType, + ExtensionRegistry registry) + { + return ReadMessageArray(field, items, messageType, registry); + } } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/DictionaryWriter.cs b/src/ProtocolBuffers/Serialization/DictionaryWriter.cs index ccfa31f0..96175a7e 100644 --- a/src/ProtocolBuffers/Serialization/DictionaryWriter.cs +++ b/src/ProtocolBuffers/Serialization/DictionaryWriter.cs @@ -1,4 +1,5 @@ using System; +using System.Collections; using System.Collections.Generic; using Google.ProtocolBuffers.Descriptors; @@ -15,8 +16,9 @@ namespace Google.ProtocolBuffers.Serialization /// Constructs a writer using a new dictionary /// public DictionaryWriter() - : this(new Dictionary(StringComparer.Ordinal)) - { } + : this(new Dictionary(StringComparer.Ordinal)) + { + } /// /// Constructs a writer using an existing dictionary @@ -38,9 +40,12 @@ namespace Google.ProtocolBuffers.Serialization /// /// Accesses the dictionary that is backing this writer /// - public IDictionary ToDictionary() { return _output; } + public IDictionary ToDictionary() + { + return _output; + } - /// + /// /// Writes the message to the the formatted stream. /// public override void WriteMessage(IMessageLite message) @@ -144,7 +149,7 @@ namespace Google.ProtocolBuffers.Serialization /// /// Writes an array of field values /// - protected override void WriteArray(FieldType fieldType, string field, System.Collections.IEnumerable items) + protected override void WriteArray(FieldType fieldType, string field, IEnumerable items) { List objects = new List(); foreach (object o in items) @@ -155,18 +160,22 @@ namespace Google.ProtocolBuffers.Serialization case FieldType.Message: { DictionaryWriter writer = Create(); - writer.WriteMessage((IMessageLite)o); + writer.WriteMessage((IMessageLite) o); objects.Add(writer.ToDictionary()); } break; case FieldType.Bytes: - objects.Add(((ByteString)o).ToByteArray()); + objects.Add(((ByteString) o).ToByteArray()); break; case FieldType.Enum: if (o is IEnumLite) - objects.Add(((IEnumLite)o).Number); + { + objects.Add(((IEnumLite) o).Number); + } else - objects.Add((int)o); + { + objects.Add((int) o); + } break; default: objects.Add(o); @@ -177,4 +186,4 @@ namespace Google.ProtocolBuffers.Serialization _output[field] = objects.ToArray(); } } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/JsonFormatReader.cs b/src/ProtocolBuffers/Serialization/JsonFormatReader.cs index 2808ff5c..d4505d70 100644 --- a/src/ProtocolBuffers/Serialization/JsonFormatReader.cs +++ b/src/ProtocolBuffers/Serialization/JsonFormatReader.cs @@ -13,28 +13,51 @@ namespace Google.ProtocolBuffers.Serialization private readonly JsonCursor _input; private readonly Stack _stopChar; - enum ReaderState { Start, BeginValue, EndValue, BeginObject, BeginArray } - string _current; - ReaderState _state; + private enum ReaderState + { + Start, + BeginValue, + EndValue, + BeginObject, + BeginArray + } + + private string _current; + private ReaderState _state; /// /// Constructs a JsonFormatReader to parse Json into a message, this method does not use text encoding, all bytes MUST /// represent ASCII character values. /// - public static JsonFormatReader CreateInstance(Stream stream) { return new JsonFormatReader(JsonCursor.CreateInstance(stream)); } + public static JsonFormatReader CreateInstance(Stream stream) + { + return new JsonFormatReader(JsonCursor.CreateInstance(stream)); + } + /// /// Constructs a JsonFormatReader to parse Json into a message, this method does not use text encoding, all bytes MUST /// represent ASCII character values. /// - public static JsonFormatReader CreateInstance(byte[] bytes) { return new JsonFormatReader(JsonCursor.CreateInstance(bytes)); } + public static JsonFormatReader CreateInstance(byte[] bytes) + { + return new JsonFormatReader(JsonCursor.CreateInstance(bytes)); + } + /// /// Constructs a JsonFormatReader to parse Json into a message /// - public static JsonFormatReader CreateInstance(string jsonText) { return new JsonFormatReader(JsonCursor.CreateInstance(jsonText)); } + public static JsonFormatReader CreateInstance(string jsonText) + { + return new JsonFormatReader(JsonCursor.CreateInstance(jsonText)); + } + /// /// Constructs a JsonFormatReader to parse Json into a message /// - public static JsonFormatReader CreateInstance(TextReader input) { return new JsonFormatReader(JsonCursor.CreateInstance(input)); } + public static JsonFormatReader CreateInstance(TextReader input) + { + return new JsonFormatReader(JsonCursor.CreateInstance(input)); + } /// /// Constructs a JsonFormatReader to parse Json into a message @@ -52,12 +75,16 @@ namespace Google.ProtocolBuffers.Serialization /// protected JsonFormatReader(TextReader input) : this(JsonCursor.CreateInstance(input)) - { } + { + } /// /// Returns true if the reader is currently on an array element /// - public bool IsArrayMessage { get { return _input.NextChar == '['; } } + public bool IsArrayMessage + { + get { return _input.NextChar == '['; } + } /// /// Returns an enumerator that is used to cursor over an array of messages @@ -68,7 +95,9 @@ namespace Google.ProtocolBuffers.Serialization public IEnumerable EnumerateArray() { foreach (string ignored in ForeachArrayItem(_current)) + { yield return this; + } } /// @@ -81,7 +110,7 @@ namespace Google.ProtocolBuffers.Serialization _state = ReaderState.BeginObject; builder.WeakMergeFrom(this, registry); - _input.Consume((char)_stopChar.Pop()); + _input.Consume((char) _stopChar.Pop()); _state = ReaderState.EndValue; return builder; } @@ -106,18 +135,24 @@ namespace Google.ProtocolBuffers.Serialization protected override bool PeekNext(out string field) { field = _current; - if(_state == ReaderState.BeginValue) + if (_state == ReaderState.BeginValue) + { return true; + } int next = _input.NextChar; if (next == _stopChar.Peek()) + { return false; + } _input.Assert(next != -1, "Unexpected end of file."); //not sure about this yet, it will allow {, "a":true } if (_state == ReaderState.EndValue && !_input.TryConsume(',')) + { return false; + } field = _current = _input.ReadString(); _input.Consume(':'); @@ -134,19 +169,31 @@ namespace Google.ProtocolBuffers.Serialization JsonCursor.JsType type = _input.ReadVariant(out temp); _state = ReaderState.EndValue; - _input.Assert(type != JsonCursor.JsType.Array && type != JsonCursor.JsType.Object, "Encountered {0} while expecting {1}", type, typeInfo); + _input.Assert(type != JsonCursor.JsType.Array && type != JsonCursor.JsType.Object, + "Encountered {0} while expecting {1}", type, typeInfo); if (type == JsonCursor.JsType.Null) + { return false; - if (type == JsonCursor.JsType.True) value = "1"; - else if (type == JsonCursor.JsType.False) value = "0"; - else value = temp as string; + } + if (type == JsonCursor.JsType.True) + { + value = "1"; + } + else if (type == JsonCursor.JsType.False) + { + value = "0"; + } + else + { + value = temp as string; + } //exponent representation of integer number: if (value != null && type == JsonCursor.JsType.Number && - (typeInfo != typeof(double) && typeInfo != typeof(float)) && + (typeInfo != typeof (double) && typeInfo != typeof (float)) && value.IndexOf("e", StringComparison.OrdinalIgnoreCase) > 0) { - value = XmlConvert.ToString((long)Math.Round(XmlConvert.ToDouble(value), 0)); + value = XmlConvert.ToString((long) Math.Round(XmlConvert.ToDouble(value), 0)); } return value != null; } @@ -177,10 +224,12 @@ namespace Google.ProtocolBuffers.Serialization { _current = field; yield return field; - if(!_input.TryConsume(',')) + if (!_input.TryConsume(',')) + { break; + } } - _input.Consume((char)_stopChar.Pop()); + _input.Consume((char) _stopChar.Pop()); _state = ReaderState.EndValue; } @@ -192,6 +241,5 @@ namespace Google.ProtocolBuffers.Serialization Merge(builder, registry); return true; } - } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/JsonFormatWriter.cs b/src/ProtocolBuffers/Serialization/JsonFormatWriter.cs index b2057524..d54507cc 100644 --- a/src/ProtocolBuffers/Serialization/JsonFormatWriter.cs +++ b/src/ProtocolBuffers/Serialization/JsonFormatWriter.cs @@ -1,4 +1,5 @@ using System; +using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; @@ -14,11 +15,12 @@ namespace Google.ProtocolBuffers.Serialization public abstract class JsonFormatWriter : AbstractTextWriter { #region buffering implementations + private class JsonTextWriter : JsonFormatWriter { private readonly char[] _buffer; private TextWriter _output; - int _bufferPos; + private int _bufferPos; public JsonTextWriter(TextWriter output) { @@ -36,7 +38,9 @@ namespace Google.ProtocolBuffers.Serialization Flush(); if (_output != null) + { return _output.ToString(); + } return new String(_buffer, 0, _bufferPos); } @@ -46,7 +50,9 @@ namespace Google.ProtocolBuffers.Serialization if (_bufferPos + len >= _buffer.Length) { if (_output == null) - _output = new StringWriter(new System.Text.StringBuilder(_buffer.Length * 2 + len)); + { + _output = new StringWriter(new StringBuilder(_buffer.Length*2 + len)); + } Flush(); } @@ -56,7 +62,9 @@ namespace Google.ProtocolBuffers.Serialization { int stop = offset + len; for (int i = offset; i < stop; i++) + { _buffer[_bufferPos++] = chars[i]; + } } else { @@ -65,13 +73,17 @@ namespace Google.ProtocolBuffers.Serialization } } else + { _output.Write(chars, offset, len); + } } protected override void WriteToOutput(char ch) { if (_bufferPos >= _buffer.Length) + { Flush(); + } _buffer[_bufferPos++] = ch; } @@ -85,16 +97,17 @@ namespace Google.ProtocolBuffers.Serialization base.Flush(); } } + private class JsonStreamWriter : JsonFormatWriter { #if SILVERLIGHT2 || COMPACT_FRAMEWORK_35 static readonly Encoding Encoding = Encoding.UTF8; #else - static readonly Encoding Encoding = Encoding.ASCII; + private static readonly Encoding Encoding = Encoding.ASCII; #endif private readonly byte[] _buffer; private Stream _output; - int _bufferPos; + private int _bufferPos; public JsonStreamWriter(Stream output) { @@ -107,7 +120,9 @@ namespace Google.ProtocolBuffers.Serialization protected override void WriteToOutput(char[] chars, int offset, int len) { if (_bufferPos + len >= _buffer.Length) + { Flush(); + } if (len < _buffer.Length) { @@ -115,7 +130,9 @@ namespace Google.ProtocolBuffers.Serialization { int stop = offset + len; for (int i = offset; i < stop; i++) - _buffer[_bufferPos++] = (byte)chars[i]; + { + _buffer[_bufferPos++] = (byte) chars[i]; + } } else { @@ -132,8 +149,10 @@ namespace Google.ProtocolBuffers.Serialization protected override void WriteToOutput(char ch) { if (_bufferPos >= _buffer.Length) + { Flush(); - _buffer[_bufferPos++] = (byte)ch; + } + _buffer[_bufferPos++] = (byte) ch; } public override void Flush() @@ -146,10 +165,12 @@ namespace Google.ProtocolBuffers.Serialization base.Flush(); } } + #endregion private readonly List _counter; private bool _isArray; + /// /// Constructs a JsonFormatWriter, use the ToString() member to extract the final Json on completion. /// @@ -161,26 +182,42 @@ namespace Google.ProtocolBuffers.Serialization /// /// Constructs a JsonFormatWriter, use ToString() to extract the final output /// - public static JsonFormatWriter CreateInstance() { return new JsonTextWriter(null); } - + public static JsonFormatWriter CreateInstance() + { + return new JsonTextWriter(null); + } + /// /// Constructs a JsonFormatWriter to output to the given text writer /// - public static JsonFormatWriter CreateInstance(TextWriter output) { return new JsonTextWriter(output); } + public static JsonFormatWriter CreateInstance(TextWriter output) + { + return new JsonTextWriter(output); + } /// /// Constructs a JsonFormatWriter to output to the given stream /// - public static JsonFormatWriter CreateInstance(Stream output) { return new JsonStreamWriter(output); } + public static JsonFormatWriter CreateInstance(Stream output) + { + return new JsonStreamWriter(output); + } /// Write to the output stream protected void WriteToOutput(string format, params object[] args) - { WriteToOutput(String.Format(format, args)); } + { + WriteToOutput(String.Format(format, args)); + } + /// Write to the output stream protected void WriteToOutput(string text) - { WriteToOutput(text.ToCharArray(), 0, text.Length); } + { + WriteToOutput(text.ToCharArray(), 0, text.Length); + } + /// Write to the output stream protected abstract void WriteToOutput(char ch); + /// Write to the output stream protected abstract void WriteToOutput(char[] chars, int offset, int len); @@ -195,19 +232,25 @@ namespace Google.ProtocolBuffers.Serialization /// Gets or sets the characters to use for the new-line, default = empty public string NewLine { get; set; } + /// Gets or sets the text to use for indenting, default = empty public string Indent { get; set; } + /// Gets or sets the whitespace to use to separate the text, default = empty public string Whitespace { get; set; } private void Seperator() { if (_counter.Count == 0) + { throw new InvalidOperationException("Missmatched open/close in Json writer."); + } int index = _counter.Count - 1; if (_counter[index] > 0) + { WriteToOutput(','); + } WriteLine(String.Empty); _counter[index] = _counter[index] + 1; @@ -219,10 +262,14 @@ namespace Google.ProtocolBuffers.Serialization { WriteToOutput(NewLine); for (int i = 1; i < _counter.Count; i++) + { WriteToOutput(Indent); + } } - else if(!String.IsNullOrEmpty(Whitespace)) + else if (!String.IsNullOrEmpty(Whitespace)) + { WriteToOutput(Whitespace); + } WriteToOutput(content); } @@ -237,7 +284,9 @@ namespace Google.ProtocolBuffers.Serialization WriteToOutput('"'); WriteToOutput(':'); if (!String.IsNullOrEmpty(Whitespace)) + { WriteToOutput(Whitespace); + } } } @@ -250,23 +299,44 @@ namespace Google.ProtocolBuffers.Serialization while (pos < len) { int next = pos; - while (next < len && text[next] >= 32 && text[next] < 127 && text[next] != '\\' && text[next] != '/' && text[next] != '"') + while (next < len && text[next] >= 32 && text[next] < 127 && text[next] != '\\' && text[next] != '/' && + text[next] != '"') + { next++; + } WriteToOutput(text, pos, next - pos); if (next < len) { switch (text[next]) { - case '"': WriteToOutput(@"\"""); break; - case '\\': WriteToOutput(@"\\"); break; - //odd at best to escape '/', most Json implementations don't, but it is defined in the rfc-4627 - case '/': WriteToOutput(@"\/"); break; - case '\b': WriteToOutput(@"\b"); break; - case '\f': WriteToOutput(@"\f"); break; - case '\n': WriteToOutput(@"\n"); break; - case '\r': WriteToOutput(@"\r"); break; - case '\t': WriteToOutput(@"\t"); break; - default: WriteToOutput(@"\u{0:x4}", (int)text[next]); break; + case '"': + WriteToOutput(@"\"""); + break; + case '\\': + WriteToOutput(@"\\"); + break; + //odd at best to escape '/', most Json implementations don't, but it is defined in the rfc-4627 + case '/': + WriteToOutput(@"\/"); + break; + case '\b': + WriteToOutput(@"\b"); + break; + case '\f': + WriteToOutput(@"\f"); + break; + case '\n': + WriteToOutput(@"\n"); + break; + case '\r': + WriteToOutput(@"\r"); + break; + case '\t': + WriteToOutput(@"\t"); + break; + default: + WriteToOutput(@"\u{0:x4}", (int) text[next]); + break; } next++; } @@ -280,15 +350,22 @@ namespace Google.ProtocolBuffers.Serialization protected override void WriteAsText(string field, string textValue, object typedValue) { WriteName(field); - if(typedValue is bool || typedValue is int || typedValue is uint || typedValue is long || typedValue is ulong || typedValue is double || typedValue is float) + if (typedValue is bool || typedValue is int || typedValue is uint || typedValue is long || + typedValue is ulong || typedValue is double || typedValue is float) + { WriteToOutput(textValue); + } else { WriteToOutput('"'); if (typedValue is string) + { EncodeText(textValue); + } else + { WriteToOutput(textValue); + } WriteToOutput('"'); } } @@ -299,7 +376,9 @@ namespace Google.ProtocolBuffers.Serialization protected override void Write(string field, double value) { if (double.IsNaN(value) || double.IsNegativeInfinity(value) || double.IsPositiveInfinity(value)) + { throw new InvalidOperationException("This format does not support NaN, Infinity, or -Infinity"); + } base.Write(field, value); } @@ -309,7 +388,9 @@ namespace Google.ProtocolBuffers.Serialization protected override void Write(string field, float value) { if (float.IsNaN(value) || float.IsNegativeInfinity(value) || float.IsPositiveInfinity(value)) + { throw new InvalidOperationException("This format does not support NaN, Infinity, or -Infinity"); + } base.Write(field, value); } @@ -322,11 +403,23 @@ namespace Google.ProtocolBuffers.Serialization /// /// Writes an array of field values /// - protected override void WriteArray(FieldType type, string field, System.Collections.IEnumerable items) + protected override void WriteArray(FieldType type, string field, IEnumerable items) { - System.Collections.IEnumerator enumerator = items.GetEnumerator(); - try { if (!enumerator.MoveNext()) return; } - finally { if (enumerator is IDisposable) ((IDisposable)enumerator).Dispose(); } + IEnumerator enumerator = items.GetEnumerator(); + try + { + if (!enumerator.MoveNext()) + { + return; + } + } + finally + { + if (enumerator is IDisposable) + { + ((IDisposable) enumerator).Dispose(); + } + } WriteName(field); WriteToOutput("["); @@ -352,7 +445,10 @@ namespace Google.ProtocolBuffers.Serialization /// public override void WriteMessage(IMessageLite message) { - if (_isArray) Seperator(); + if (_isArray) + { + Seperator(); + } WriteToOutput("{"); _counter.Add(0); message.WriteTo(this); @@ -371,9 +467,10 @@ namespace Google.ProtocolBuffers.Serialization /// writer.WriteMessage(m); /// /// - public sealed class JsonArray : IDisposable + public sealed class JsonArray : IDisposable { - JsonFormatWriter _writer; + private JsonFormatWriter _writer; + internal JsonArray(JsonFormatWriter writer) { _writer = writer; @@ -384,7 +481,7 @@ namespace Google.ProtocolBuffers.Serialization /// /// Causes the end of the array character to be written. /// - void EndArray() + private void EndArray() { if (_writer != null) { @@ -392,9 +489,13 @@ namespace Google.ProtocolBuffers.Serialization _writer.WriteLine("]"); _writer.Flush(); } - _writer = null; + _writer = null; + } + + void IDisposable.Dispose() + { + EndArray(); } - void IDisposable.Dispose() { EndArray(); } } /// @@ -409,7 +510,10 @@ namespace Google.ProtocolBuffers.Serialization /// public JsonArray StartArray() { - if (_isArray) Seperator(); + if (_isArray) + { + Seperator(); + } _isArray = true; return new JsonArray(this); } diff --git a/src/ProtocolBuffers/Serialization/JsonTextCursor.cs b/src/ProtocolBuffers/Serialization/JsonTextCursor.cs index a0b468f6..48e84ccc 100644 --- a/src/ProtocolBuffers/Serialization/JsonTextCursor.cs +++ b/src/ProtocolBuffers/Serialization/JsonTextCursor.cs @@ -1,20 +1,30 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Globalization; using System.IO; -using System.Text; namespace Google.ProtocolBuffers.Serialization { /// /// JSon Tokenizer used by JsonFormatReader /// - abstract class JsonCursor + internal abstract class JsonCursor { - public enum JsType { String, Number, Object, Array, True, False, Null } + public enum JsType + { + String, + Number, + Object, + Array, + True, + False, + Null + } #region Buffering implementations - class JsonStreamCursor : JsonCursor + + private class JsonStreamCursor : JsonCursor { private readonly byte[] _buffer; private int _bufferPos; @@ -25,6 +35,7 @@ namespace Google.ProtocolBuffers.Serialization _input = input; _next = _input.ReadByte(); } + public JsonStreamCursor(byte[] input) { _input = null; @@ -35,11 +46,17 @@ namespace Google.ProtocolBuffers.Serialization protected override int Peek() { if (_input != null) + { return _next; + } else if (_bufferPos < _buffer.Length) + { return _buffer[_bufferPos]; + } else + { return -1; + } } protected override int Read() @@ -51,13 +68,17 @@ namespace Google.ProtocolBuffers.Serialization return result; } else if (_bufferPos < _buffer.Length) + { return _buffer[_bufferPos++]; + } else + { return -1; + } } } - class JsonTextCursor : JsonCursor + private class JsonTextCursor : JsonCursor { private readonly char[] _buffer; private int _bufferPos; @@ -80,55 +101,95 @@ namespace Google.ProtocolBuffers.Serialization protected override int Peek() { if (_input != null) + { return _input.Peek(); + } else if (_bufferPos < _buffer.Length) + { return _buffer[_bufferPos]; + } else + { return -1; + } } protected override int Read() { if (_input != null) + { return _input.Read(); + } else if (_bufferPos < _buffer.Length) + { return _buffer[_bufferPos++]; + } else + { return -1; + } } } + #endregion protected int _next; private int _lineNo, _linePos; - public static JsonCursor CreateInstance(byte[] input) { return new JsonStreamCursor(input); } - public static JsonCursor CreateInstance(Stream input) { return new JsonStreamCursor(input); } - public static JsonCursor CreateInstance(string input) { return new JsonTextCursor(input.ToCharArray()); } - public static JsonCursor CreateInstance(TextReader input) { return new JsonTextCursor(input); } + public static JsonCursor CreateInstance(byte[] input) + { + return new JsonStreamCursor(input); + } + + public static JsonCursor CreateInstance(Stream input) + { + return new JsonStreamCursor(input); + } + + public static JsonCursor CreateInstance(string input) + { + return new JsonTextCursor(input.ToCharArray()); + } + + public static JsonCursor CreateInstance(TextReader input) + { + return new JsonTextCursor(input); + } protected JsonCursor() { _lineNo = 1; _linePos = 0; } - + /// Returns the next character without actually 'reading' it protected abstract int Peek(); + /// Reads the next character in the input protected abstract int Read(); - public Char NextChar { get { SkipWhitespace(); return (char)_next; } } + public Char NextChar + { + get + { + SkipWhitespace(); + return (char) _next; + } + } #region Assert(...) - [System.Diagnostics.DebuggerNonUserCode] + + [DebuggerNonUserCode] private string CharDisplay(int ch) { - return ch == -1 ? "EOF" : - (ch > 32 && ch < 127) ? String.Format("'{0}'", (char)ch) : - String.Format("'\\u{0:x4}'", ch); + return ch == -1 + ? "EOF" + : (ch > 32 && ch < 127) + ? String.Format("'{0}'", (char) ch) + : String.Format("'\\u{0:x4}'", ch); } - [System.Diagnostics.DebuggerNonUserCode] + + [DebuggerNonUserCode] private void Assert(bool cond, char expected) { if (!cond) @@ -136,13 +197,14 @@ namespace Google.ProtocolBuffers.Serialization throw new FormatException( String.Format(CultureInfo.InvariantCulture, "({0}:{1}) error: Unexpected token {2}, expected: {3}.", - _lineNo, _linePos, + _lineNo, _linePos, CharDisplay(_next), CharDisplay(expected) )); } } - [System.Diagnostics.DebuggerNonUserCode] + + [DebuggerNonUserCode] public void Assert(bool cond, string message) { if (!cond) @@ -152,18 +214,22 @@ namespace Google.ProtocolBuffers.Serialization "({0},{1}) error: {2}", _lineNo, _linePos, message)); } } - [System.Diagnostics.DebuggerNonUserCode] + + [DebuggerNonUserCode] public void Assert(bool cond, string format, params object[] args) { if (!cond) { if (args != null && args.Length > 0) + { format = String.Format(format, args); + } throw new FormatException( String.Format(CultureInfo.InvariantCulture, "({0},{1}) error: {2}", _lineNo, _linePos, format)); } } + #endregion private char ReadChar() @@ -180,10 +246,14 @@ namespace Google.ProtocolBuffers.Serialization _linePos++; } _next = Peek(); - return (char)ch; + return (char) ch; + } + + public void Consume(char ch) + { + Assert(TryConsume(ch), ch); } - public void Consume(char ch) { Assert(TryConsume(ch), ch); } public bool TryConsume(char ch) { SkipWhitespace(); @@ -200,7 +270,9 @@ namespace Google.ProtocolBuffers.Serialization SkipWhitespace(); foreach (char ch in sequence) + { Assert(ch == ReadChar(), "Expected token '{0}'.", sequence); + } } public void SkipWhitespace() @@ -208,8 +280,10 @@ namespace Google.ProtocolBuffers.Serialization int chnext = _next; while (chnext != -1) { - if (!Char.IsWhiteSpace((char)chnext)) + if (!Char.IsWhiteSpace((char) chnext)) + { break; + } ReadChar(); chnext = _next; } @@ -224,26 +298,39 @@ namespace Google.ProtocolBuffers.Serialization { if (_next == '\\') { - Consume('\\');//skip the escape + Consume('\\'); //skip the escape char ch = ReadChar(); switch (ch) { - case 'b': sb.Add('\b'); break; - case 'f': sb.Add('\f'); break; - case 'n': sb.Add('\n'); break; - case 'r': sb.Add('\r'); break; - case 't': sb.Add('\t'); break; + case 'b': + sb.Add('\b'); + break; + case 'f': + sb.Add('\f'); + break; + case 'n': + sb.Add('\n'); + break; + case 'r': + sb.Add('\r'); + break; + case 't': + sb.Add('\t'); + break; case 'u': { - string hex = new string(new char[] { ReadChar(), ReadChar(), ReadChar(), ReadChar() }); + string hex = new string(new char[] {ReadChar(), ReadChar(), ReadChar(), ReadChar()}); int result; - Assert(int.TryParse(hex, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out result), - "Expected a 4-character hex specifier."); - sb.Add((char)result); + Assert( + int.TryParse(hex, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, + out result), + "Expected a 4-character hex specifier."); + sb.Add((char) result); break; } default: - sb.Add(ch); break; + sb.Add(ch); + break; } } else @@ -261,18 +348,26 @@ namespace Google.ProtocolBuffers.Serialization SkipWhitespace(); List sb = new List(24); if (_next == '-') + { sb.Add(ReadChar()); + } Assert(_next >= '0' && _next <= '9', "Expected a numeric type."); while ((_next >= '0' && _next <= '9') || _next == '.') + { sb.Add(ReadChar()); + } if (_next == 'e' || _next == 'E') { sb.Add(ReadChar()); if (_next == '-' || _next == '+') + { sb.Add(ReadChar()); + } Assert(_next >= '0' && _next <= '9', "Expected a numeric type."); while (_next >= '0' && _next <= '9') + { sb.Add(ReadChar()); + } } return new String(sb.ToArray()); } @@ -282,10 +377,21 @@ namespace Google.ProtocolBuffers.Serialization SkipWhitespace(); switch (_next) { - case 'n': Consume("null"); value = null; return JsType.Null; - case 't': Consume("true"); value = true; return JsType.True; - case 'f': Consume("false"); value = false; return JsType.False; - case '"': value = ReadString(); return JsType.String; + case 'n': + Consume("null"); + value = null; + return JsType.Null; + case 't': + Consume("true"); + value = true; + return JsType.True; + case 'f': + Consume("false"); + value = false; + return JsType.False; + case '"': + value = ReadString(); + return JsType.String; case '{': { Consume('{'); @@ -296,7 +402,9 @@ namespace Google.ProtocolBuffers.Serialization object tmp; ReadVariant(out tmp); if (!TryConsume(',')) + { break; + } } Consume('}'); value = null; @@ -312,7 +420,9 @@ namespace Google.ProtocolBuffers.Serialization ReadVariant(out tmp); values.Add(tmp); if (!TryConsume(',')) + { break; + } } Consume(']'); value = values.ToArray(); diff --git a/src/ProtocolBuffers/Serialization/XmlFormatReader.cs b/src/ProtocolBuffers/Serialization/XmlFormatReader.cs index f3ca1314..112910a7 100644 --- a/src/ProtocolBuffers/Serialization/XmlFormatReader.cs +++ b/src/ProtocolBuffers/Serialization/XmlFormatReader.cs @@ -2,7 +2,6 @@ using System.Collections.Generic; using System.IO; using System.Xml; -using Google.ProtocolBuffers.Descriptors; namespace Google.ProtocolBuffers.Serialization { @@ -17,31 +16,55 @@ namespace Google.ProtocolBuffers.Serialization private readonly XmlReader _input; private string _rootElementName; - static XmlReaderSettings DefaultSettings + private static XmlReaderSettings DefaultSettings { - get { return new XmlReaderSettings() { CheckCharacters=false, IgnoreComments=true, IgnoreProcessingInstructions = true }; } + get + { + return new XmlReaderSettings() + {CheckCharacters = false, IgnoreComments = true, IgnoreProcessingInstructions = true}; + } } /// /// Constructs the XmlFormatReader using the stream provided as the xml /// - public static XmlFormatReader CreateInstance(byte[] input) { return new XmlFormatReader(XmlReader.Create(new MemoryStream(input, false), DefaultSettings)); } + public static XmlFormatReader CreateInstance(byte[] input) + { + return new XmlFormatReader(XmlReader.Create(new MemoryStream(input, false), DefaultSettings)); + } + /// /// Constructs the XmlFormatReader using the stream provided as the xml /// - public static XmlFormatReader CreateInstance(Stream input) { return new XmlFormatReader(XmlReader.Create(input, DefaultSettings)); } + public static XmlFormatReader CreateInstance(Stream input) + { + return new XmlFormatReader(XmlReader.Create(input, DefaultSettings)); + } + /// /// Constructs the XmlFormatReader using the string provided as the xml to be read /// - public static XmlFormatReader CreateInstance(String input) { return new XmlFormatReader(XmlReader.Create(new StringReader(input), DefaultSettings)); } + public static XmlFormatReader CreateInstance(String input) + { + return new XmlFormatReader(XmlReader.Create(new StringReader(input), DefaultSettings)); + } + /// /// Constructs the XmlFormatReader using the xml in the TextReader /// - public static XmlFormatReader CreateInstance(TextReader input) { return new XmlFormatReader(XmlReader.Create(input, DefaultSettings)); } + public static XmlFormatReader CreateInstance(TextReader input) + { + return new XmlFormatReader(XmlReader.Create(input, DefaultSettings)); + } + /// /// Constructs the XmlFormatReader with the XmlReader /// - public static XmlFormatReader CreateInstance(XmlReader input) { return new XmlFormatReader(input); } + public static XmlFormatReader CreateInstance(XmlReader input) + { + return new XmlFormatReader(input); + } + /// /// Constructs the XmlFormatReader with the XmlReader and options /// @@ -51,23 +74,32 @@ namespace Google.ProtocolBuffers.Serialization _rootElementName = DefaultRootElementName; Options = XmlReaderOptions.None; } - + /// /// Gets or sets the options to use when reading the xml /// public XmlReaderOptions Options { get; set; } + /// /// Sets the options to use while generating the XML /// - public XmlFormatReader SetOptions(XmlReaderOptions options) { Options = options; return this; } + public XmlFormatReader SetOptions(XmlReaderOptions options) + { + Options = options; + return this; + } /// /// Gets or sets the default element name to use when using the Merge<TBuilder>() /// - public string RootElementName + public string RootElementName { - get { return _rootElementName; } - set { ThrowHelper.ThrowIfNull(value, "RootElementName"); _rootElementName = value; } + get { return _rootElementName; } + set + { + ThrowHelper.ThrowIfNull(value, "RootElementName"); + _rootElementName = value; + } } private XmlFormatReader CloneWith(XmlReader rdr) @@ -76,34 +108,45 @@ namespace Google.ProtocolBuffers.Serialization copy._rootElementName = _rootElementName; copy.Depth = Depth; return copy; - } + private void NextElement() { while (!_input.IsStartElement() && _input.Read()) + { continue; + } } + private static void Assert(bool cond) { - if (!cond) throw new FormatException(); + if (!cond) + { + throw new FormatException(); + } } /// /// Merge the provided builder as an element named in the current context /// public override TBuilder Merge(TBuilder builder, ExtensionRegistry registry) - { return Merge(_rootElementName, builder, registry); } + { + return Merge(_rootElementName, builder, registry); + } /// /// Merge the provided builder as an element of the current context /// public TBuilder Merge(string element, TBuilder builder) where TBuilder : IBuilderLite - { return Merge(element, builder, ExtensionRegistry.Empty); } + { + return Merge(element, builder, ExtensionRegistry.Empty); + } /// /// Merge the provided builder as an element of the current context /// - public TBuilder Merge(string element, TBuilder builder, ExtensionRegistry registry) where TBuilder : IBuilderLite + public TBuilder Merge(string element, TBuilder builder, ExtensionRegistry registry) + where TBuilder : IBuilderLite { string field; Assert(PeekNext(out field) && field == element); @@ -121,7 +164,7 @@ namespace Google.ProtocolBuffers.Serialization protected override bool PeekNext(out string field) { NextElement(); - if(_input.IsStartElement()) + if (_input.IsStartElement()) { field = _input.LocalName; return true; @@ -141,7 +184,9 @@ namespace Google.ProtocolBuffers.Serialization { int depth = _input.Depth; while (_input.Depth >= depth && _input.NodeType != XmlNodeType.EndElement) + { Assert(_input.Read()); + } } _input.Read(); } @@ -171,7 +216,7 @@ namespace Google.ProtocolBuffers.Serialization { Assert(_input.NodeType == XmlNodeType.Element); value = _input.ReadElementContentAsString(); - + return true; } @@ -187,7 +232,9 @@ namespace Google.ProtocolBuffers.Serialization int depth = _input.Depth; XmlReader child = _input.ReadSubtree(); while (!child.IsStartElement() && child.Read()) + { continue; + } child.Read(); builder.WeakMergeFrom(CloneWith(child), registry); Assert(depth == _input.Depth && _input.NodeType == XmlNodeType.EndElement); @@ -211,7 +258,9 @@ namespace Google.ProtocolBuffers.Serialization if (!isNested) { foreach (string item in NonNestedArrayItems(field)) + { yield return item; + } yield break; } if (!_input.IsEmptyElement) @@ -220,15 +269,19 @@ namespace Google.ProtocolBuffers.Serialization XmlReader child = _input.ReadSubtree(); while (!child.IsStartElement() && child.Read()) + { continue; + } child.Read(); foreach (string item in CloneWith(child).NonNestedArrayItems("item")) + { yield return item; + } Assert(depth == _input.Depth && _input.NodeType == XmlNodeType.EndElement); } _input.Read(); yield break; } } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/XmlFormatWriter.cs b/src/ProtocolBuffers/Serialization/XmlFormatWriter.cs index 1be2f390..fd36c1de 100644 --- a/src/ProtocolBuffers/Serialization/XmlFormatWriter.cs +++ b/src/ProtocolBuffers/Serialization/XmlFormatWriter.cs @@ -1,4 +1,5 @@ using System; +using System.Collections; using System.IO; using System.Text; using System.Xml; @@ -18,33 +19,48 @@ namespace Google.ProtocolBuffers.Serialization private readonly XmlWriter _output; private string _rootElementName; - static XmlWriterSettings DefaultSettings(Encoding encoding) + private static XmlWriterSettings DefaultSettings(Encoding encoding) { - return new XmlWriterSettings() - { - CheckCharacters = false, - NewLineHandling = NewLineHandling.Entitize, - OmitXmlDeclaration = true, - Encoding = encoding, - }; + return new XmlWriterSettings() + { + CheckCharacters = false, + NewLineHandling = NewLineHandling.Entitize, + OmitXmlDeclaration = true, + Encoding = encoding, + }; } /// /// Constructs the XmlFormatWriter to write to the given TextWriter /// - public static XmlFormatWriter CreateInstance(TextWriter output) { return new XmlFormatWriter(XmlWriter.Create(output, DefaultSettings(output.Encoding))); } + public static XmlFormatWriter CreateInstance(TextWriter output) + { + return new XmlFormatWriter(XmlWriter.Create(output, DefaultSettings(output.Encoding))); + } + /// /// Constructs the XmlFormatWriter to write to the given stream /// - public static XmlFormatWriter CreateInstance(Stream output) { return new XmlFormatWriter(XmlWriter.Create(output, DefaultSettings(Encoding.UTF8))); } + public static XmlFormatWriter CreateInstance(Stream output) + { + return new XmlFormatWriter(XmlWriter.Create(output, DefaultSettings(Encoding.UTF8))); + } + /// /// Constructs the XmlFormatWriter to write to the given stream /// - public static XmlFormatWriter CreateInstance(Stream output, Encoding encoding) { return new XmlFormatWriter(XmlWriter.Create(output, DefaultSettings(encoding))); } + public static XmlFormatWriter CreateInstance(Stream output, Encoding encoding) + { + return new XmlFormatWriter(XmlWriter.Create(output, DefaultSettings(encoding))); + } + /// /// Constructs the XmlFormatWriter to write to the given XmlWriter /// - public static XmlFormatWriter CreateInstance(XmlWriter output) { return new XmlFormatWriter(output); } + public static XmlFormatWriter CreateInstance(XmlWriter output) + { + return new XmlFormatWriter(output); + } protected XmlFormatWriter(XmlWriter output) { @@ -57,8 +73,10 @@ namespace Google.ProtocolBuffers.Serialization /// protected override void Dispose(bool disposing) { - if(disposing) + if (disposing) + { _output.Close(); + } } /// @@ -67,25 +85,39 @@ namespace Google.ProtocolBuffers.Serialization public string RootElementName { get { return _rootElementName; } - set { ThrowHelper.ThrowIfNull(value, "RootElementName"); _rootElementName = value; } + set + { + ThrowHelper.ThrowIfNull(value, "RootElementName"); + _rootElementName = value; + } } /// /// Gets or sets the options to use while generating the XML /// public XmlWriterOptions Options { get; set; } + /// /// Sets the options to use while generating the XML /// - public XmlFormatWriter SetOptions(XmlWriterOptions options) { Options = options; return this; } + public XmlFormatWriter SetOptions(XmlWriterOptions options) + { + Options = options; + return this; + } - private bool TestOption(XmlWriterOptions option) { return (Options & option) != 0; } + private bool TestOption(XmlWriterOptions option) + { + return (Options & option) != 0; + } /// /// Writes a message as an element using the name defined in /// public override void WriteMessage(IMessageLite message) - { WriteMessage(_rootElementName, message); } + { + WriteMessage(_rootElementName, message); + } /// /// Writes a message as an element with the given name @@ -98,7 +130,9 @@ namespace Google.ProtocolBuffers.Serialization _output.WriteAttributeString("type", "object"); } else + { _output.WriteStartElement(elementName); + } message.WriteTo(this); _output.WriteEndElement(); @@ -113,7 +147,9 @@ namespace Google.ProtocolBuffers.Serialization _output.WriteStartElement(field); if (TestOption(XmlWriterOptions.OutputJsonTypes)) + { _output.WriteAttributeString("type", "object"); + } message.WriteTo(this); _output.WriteEndElement(); @@ -128,16 +164,23 @@ namespace Google.ProtocolBuffers.Serialization if (TestOption(XmlWriterOptions.OutputJsonTypes)) { - if (typedValue is int || typedValue is uint || typedValue is long || typedValue is ulong || typedValue is double || typedValue is float) + if (typedValue is int || typedValue is uint || typedValue is long || typedValue is ulong || + typedValue is double || typedValue is float) + { _output.WriteAttributeString("type", "number"); + } else if (typedValue is bool) + { _output.WriteAttributeString("type", "boolean"); + } } _output.WriteString(textValue); //Empty strings should not be written as empty elements '', rather as '' if (_output.WriteState == WriteState.Element) + { _output.WriteRaw(""); + } _output.WriteEndElement(); } @@ -145,25 +188,40 @@ namespace Google.ProtocolBuffers.Serialization /// /// Writes an array of field values /// - protected override void WriteArray(FieldType fieldType, string field, System.Collections.IEnumerable items) + protected override void WriteArray(FieldType fieldType, string field, IEnumerable items) { //see if it's empty - System.Collections.IEnumerator eitems = items.GetEnumerator(); - try { if (!eitems.MoveNext()) return; } + IEnumerator eitems = items.GetEnumerator(); + try + { + if (!eitems.MoveNext()) + { + return; + } + } finally - { if (eitems is IDisposable) ((IDisposable) eitems).Dispose(); } + { + if (eitems is IDisposable) + { + ((IDisposable) eitems).Dispose(); + } + } if (TestOption(XmlWriterOptions.OutputNestedArrays | XmlWriterOptions.OutputJsonTypes)) { _output.WriteStartElement(field); if (TestOption(XmlWriterOptions.OutputJsonTypes)) + { _output.WriteAttributeString("type", "array"); + } base.WriteArray(fieldType, "item", items); _output.WriteEndElement(); } else + { base.WriteArray(fieldType, field, items); + } } /// @@ -174,10 +232,12 @@ namespace Google.ProtocolBuffers.Serialization _output.WriteStartElement(field); if (!TestOption(XmlWriterOptions.OutputJsonTypes) && TestOption(XmlWriterOptions.OutputEnumValues)) + { _output.WriteAttributeString("value", XmlConvert.ToString(number)); + } _output.WriteString(name); _output.WriteEndElement(); } } -} +} \ No newline at end of file diff --git a/src/ProtocolBuffers/Serialization/XmlReaderOptions.cs b/src/ProtocolBuffers/Serialization/XmlReaderOptions.cs index fc75e4b5..f7eca1d7 100644 --- a/src/ProtocolBuffers/Serialization/XmlReaderOptions.cs +++ b/src/ProtocolBuffers/Serialization/XmlReaderOptions.cs @@ -10,6 +10,7 @@ namespace Google.ProtocolBuffers.Serialization { /// Simple xml formatting with no attributes None, + /// Requires that arrays items are nested in an <item> element ReadNestedArrays = 1, } diff --git a/src/ProtocolBuffers/Serialization/XmlWriterOptions.cs b/src/ProtocolBuffers/Serialization/XmlWriterOptions.cs index 2d91c742..7d740ee3 100644 --- a/src/ProtocolBuffers/Serialization/XmlWriterOptions.cs +++ b/src/ProtocolBuffers/Serialization/XmlWriterOptions.cs @@ -10,10 +10,13 @@ namespace Google.ProtocolBuffers.Serialization { /// Simple xml formatting with no attributes None, + /// Writes the 'value' attribute on all enumerations with the numeric identifier OutputEnumValues = 0x1, + /// Embeds array items into child <item> elements OutputNestedArrays = 0x4, + /// Outputs the 'type' attribute for compatibility with the JsonReaderWriterFactory /// This option must, by nessessity, also enable NestedArrayItems OutputJsonTypes = 0x8, diff --git a/src/ProtocolBuffers/TextFormat.cs b/src/ProtocolBuffers/TextFormat.cs index 77aaa8fa..bbc76186 100644 --- a/src/ProtocolBuffers/TextFormat.cs +++ b/src/ProtocolBuffers/TextFormat.cs @@ -35,12 +35,12 @@ #endregion using System; +using System.Collections; using System.Collections.Generic; using System.Globalization; using System.IO; using System.Text; using Google.ProtocolBuffers.Descriptors; -using System.Collections; namespace Google.ProtocolBuffers { @@ -166,14 +166,14 @@ namespace Google.ProtocolBuffers { switch (field.FieldType) { - // The Float and Double types must specify the "r" format to preserve their precision, otherwise, - // the double to/from string will trim the precision to 6 places. As with other numeric formats - // below, always use the invariant culture so it's predictable. + // The Float and Double types must specify the "r" format to preserve their precision, otherwise, + // the double to/from string will trim the precision to 6 places. As with other numeric formats + // below, always use the invariant culture so it's predictable. case FieldType.Float: - generator.Print(((float)value).ToString("r", CultureInfo.InvariantCulture)); + generator.Print(((float) value).ToString("r", CultureInfo.InvariantCulture)); break; case FieldType.Double: - generator.Print(((double)value).ToString("r", CultureInfo.InvariantCulture)); + generator.Print(((double) value).ToString("r", CultureInfo.InvariantCulture)); break; case FieldType.Int32: @@ -756,7 +756,9 @@ namespace Google.ProtocolBuffers { subBuilder = extension.DefaultInstance.WeakCreateBuilderForType() as IBuilder; if (subBuilder == null) + { throw new NotSupportedException("Lite messages are not supported."); + } } while (!tokenizer.TryConsume(endToken)) diff --git a/src/ProtocolBuffers/UnknownFieldSet.cs b/src/ProtocolBuffers/UnknownFieldSet.cs index 0918503e..9261dbae 100644 --- a/src/ProtocolBuffers/UnknownFieldSet.cs +++ b/src/ProtocolBuffers/UnknownFieldSet.cs @@ -39,7 +39,6 @@ using System.Collections.Generic; using System.IO; using Google.ProtocolBuffers.Collections; using Google.ProtocolBuffers.Descriptors; -using Google.ProtocolBuffers.DescriptorProtos; namespace Google.ProtocolBuffers { @@ -426,12 +425,16 @@ namespace Google.ProtocolBuffers if (tag == 0) { if (input.SkipField()) + { continue; //can't merge unknown without field tag + } break; } - if(!MergeFieldFrom(tag, input)) + if (!MergeFieldFrom(tag, input)) + { break; + } } return this; } @@ -458,29 +461,37 @@ namespace Google.ProtocolBuffers case WireFormat.WireType.Varint: { ulong uint64 = 0; - if(input.ReadUInt64(ref uint64)) + if (input.ReadUInt64(ref uint64)) + { GetFieldBuilder(number).AddVarint(uint64); + } return true; } case WireFormat.WireType.Fixed32: { uint uint32 = 0; if (input.ReadFixed32(ref uint32)) + { GetFieldBuilder(number).AddFixed32(uint32); + } return true; } case WireFormat.WireType.Fixed64: { ulong uint64 = 0; if (input.ReadFixed64(ref uint64)) + { GetFieldBuilder(number).AddFixed64(uint64); + } return true; } case WireFormat.WireType.LengthDelimited: { ByteString bytes = null; if (input.ReadBytes(ref bytes)) + { GetFieldBuilder(number).AddLengthDelimited(bytes); + } return true; } case WireFormat.WireType.StartGroup: @@ -617,18 +628,24 @@ namespace Google.ProtocolBuffers { FieldDescriptor fieldByName = builder.DescriptorForType.FindFieldByName(name); if (fieldByName != null) + { tag = WireFormat.MakeTag(fieldByName); + } else { ExtensionInfo extension = extensionRegistry.FindByName(builder.DescriptorForType, name); if (extension != null) + { tag = WireFormat.MakeTag(extension.Descriptor); + } } } if (tag == 0) { if (input.SkipField()) + { continue; //can't merge unknown without field tag + } break; } @@ -650,18 +667,23 @@ namespace Google.ProtocolBuffers /// The tag, which should already have been read from the input /// true unless the tag is an end-group tag internal bool MergeFieldFrom(ICodedInputStream input, - ExtensionRegistry extensionRegistry, IBuilder builder, uint tag, string fieldName) + ExtensionRegistry extensionRegistry, IBuilder builder, uint tag, + string fieldName) { if (tag == 0 && fieldName != null) { FieldDescriptor fieldByName = builder.DescriptorForType.FindFieldByName(fieldName); if (fieldByName != null) + { tag = WireFormat.MakeTag(fieldByName); + } else { ExtensionInfo extension = extensionRegistry.FindByName(builder.DescriptorForType, fieldName); if (extension != null) + { tag = WireFormat.MakeTag(extension.Descriptor); + } } } @@ -709,12 +731,15 @@ namespace Google.ProtocolBuffers //Allowed as of 2.3, this is unpacked data for a packed array } else if (field.IsRepeated && wireType == WireFormat.WireType.LengthDelimited && - (expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 || expectedType == WireFormat.WireType.Fixed64)) + (expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 || + expectedType == WireFormat.WireType.Fixed64)) { //Allowed as of 2.3, this is packed data for an unpacked array } else + { return MergeFieldFrom(tag, input); + } } switch (field.FieldType) @@ -722,26 +747,40 @@ namespace Google.ProtocolBuffers case FieldType.Group: case FieldType.Message: { - IBuilderLite subBuilder = (defaultFieldInstance != null) ? defaultFieldInstance.WeakCreateBuilderForType() : builder.CreateBuilderForField(field); + IBuilderLite subBuilder = (defaultFieldInstance != null) + ? defaultFieldInstance.WeakCreateBuilderForType() + : builder.CreateBuilderForField(field); if (!field.IsRepeated) { - subBuilder.WeakMergeFrom((IMessageLite)builder[field]); + subBuilder.WeakMergeFrom((IMessageLite) builder[field]); if (field.FieldType == FieldType.Group) + { input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); + } else + { input.ReadMessage(subBuilder, extensionRegistry); + } builder[field] = subBuilder.WeakBuild(); } else { List list = new List(); if (field.FieldType == FieldType.Group) - input.ReadGroupArray(tag, fieldName, list, subBuilder.WeakDefaultInstanceForType, extensionRegistry); + { + input.ReadGroupArray(tag, fieldName, list, subBuilder.WeakDefaultInstanceForType, + extensionRegistry); + } else - input.ReadMessageArray(tag, fieldName, list, subBuilder.WeakDefaultInstanceForType, extensionRegistry); + { + input.ReadMessageArray(tag, fieldName, list, subBuilder.WeakDefaultInstanceForType, + extensionRegistry); + } foreach (IMessageLite m in list) + { builder.WeakAddRepeatedField(field, m); + } return true; } break; @@ -753,24 +792,34 @@ namespace Google.ProtocolBuffers object unknown; IEnumLite value = null; if (input.ReadEnum(ref value, out unknown, field.EnumType)) + { builder[field] = value; - else if(unknown is int) - MergeVarintField(fieldNumber, (ulong)(int)unknown); + } + else if (unknown is int) + { + MergeVarintField(fieldNumber, (ulong) (int) unknown); + } } else { ICollection unknown; List list = new List(); input.ReadEnumArray(tag, fieldName, list, out unknown, field.EnumType); - + foreach (IEnumLite en in list) + { builder.WeakAddRepeatedField(field, en); + } if (unknown != null) { foreach (object oval in unknown) + { if (oval is int) - MergeVarintField(fieldNumber, (ulong)(int)oval); + { + MergeVarintField(fieldNumber, (ulong) (int) oval); + } + } } } break; @@ -781,14 +830,18 @@ namespace Google.ProtocolBuffers { object value = null; if (input.ReadPrimitiveField(field.FieldType, ref value)) + { builder[field] = value; + } } else { List list = new List(); input.ReadPrimitiveArray(field.FieldType, tag, fieldName, list); foreach (object oval in list) + { builder.WeakAddRepeatedField(field, oval); + } } break; } @@ -832,13 +885,21 @@ namespace Google.ProtocolBuffers { if (tag == 0 && name != null) { - if (name == "type_id") tag = WireFormat.MessageSetTag.TypeID; - else if (name == "message") tag = WireFormat.MessageSetTag.Message; + if (name == "type_id") + { + tag = WireFormat.MessageSetTag.TypeID; + } + else if (name == "message") + { + tag = WireFormat.MessageSetTag.Message; + } } if (tag == 0) { if (input.SkipField()) + { continue; //can't merge unknown without field tag + } break; } @@ -882,7 +943,7 @@ namespace Google.ProtocolBuffers } else if (tag == WireFormat.MessageSetTag.Message) { - if(subBuilder != null) + if (subBuilder != null) { // We already know the type, so we can parse directly from the input // with no copying. Hooray! @@ -909,7 +970,9 @@ namespace Google.ProtocolBuffers } if (lastTag != WireFormat.MessageSetTag.ItemEnd) + { throw InvalidProtocolBufferException.InvalidEndTag(); + } if (subBuilder != null) { diff --git a/src/ProtocolBuffers/WireFormat.cs b/src/ProtocolBuffers/WireFormat.cs index 328d7bc0..a03f1652 100644 --- a/src/ProtocolBuffers/WireFormat.cs +++ b/src/ProtocolBuffers/WireFormat.cs @@ -143,6 +143,7 @@ namespace Google.ProtocolBuffers } #endif + /// /// Converts a field type to its wire type. Done with a switch for the sake /// of speed - this is significantly faster than a dictionary lookup. -- cgit v1.2.3