From cc8d2aaa3a0b6bed6677fd488bc7deecd90f5604 Mon Sep 17 00:00:00 2001 From: csharptest Date: Fri, 3 Jun 2011 12:15:42 -0500 Subject: Extracted initial ICodedOutputStream interface --- .../CodedOutputStream.ComputeSize.cs | 617 +++++++++++++++++++++ src/ProtocolBuffers/CodedOutputStream.cs | 568 +------------------ src/ProtocolBuffers/ICodedOutputStream.cs | 84 +++ src/ProtocolBuffers/ProtocolBuffers.csproj | 2 + 4 files changed, 706 insertions(+), 565 deletions(-) create mode 100644 src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs create mode 100644 src/ProtocolBuffers/ICodedOutputStream.cs (limited to 'src/ProtocolBuffers') diff --git a/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs b/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs new file mode 100644 index 00000000..5533ed5b --- /dev/null +++ b/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs @@ -0,0 +1,617 @@ +#region Copyright notice and license + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// http://github.com/jskeet/dotnet-protobufs/ +// Original C++/Java/Python code: +// http://code.google.com/p/protobuf/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// 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. + +#endregion + +using System; +using System.Globalization; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers +{ + /// + /// Encodes and writes protocol message fields. + /// + /// + /// This class contains two kinds of methods: methods that write specific + /// protocol message constructs and field types (e.g. WriteTag and + /// WriteInt32) and methods that write low-level values (e.g. + /// WriteRawVarint32 and WriteRawBytes). If you are writing encoded protocol + /// messages, you should use the former methods, but if you are writing some + /// other format of your own design, use the latter. The names of the former + /// methods are taken from the protocol buffer type names, not .NET types. + /// (Hence WriteFloat instead of WriteSingle, and WriteBool instead of WriteBoolean.) + /// + public sealed partial class CodedOutputStream + { + private const int LittleEndian64Size = 8; + private const int LittleEndian32Size = 4; + + /// + /// Compute the number of bytes that would be needed to encode a + /// double field, including the tag. + /// + public static int ComputeDoubleSize(int fieldNumber, double value) + { + return ComputeTagSize(fieldNumber) + LittleEndian64Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// float field, including the tag. + /// + public static int ComputeFloatSize(int fieldNumber, float value) + { + return ComputeTagSize(fieldNumber) + LittleEndian32Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// uint64 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeUInt64Size(int fieldNumber, ulong value) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// int64 field, including the tag. + /// + public static int ComputeInt64Size(int fieldNumber, long value) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size((ulong) value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// int32 field, including the tag. + /// + public static int ComputeInt32Size(int fieldNumber, int value) + { + if (value >= 0) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) value); + } + else + { + // Must sign-extend. + return ComputeTagSize(fieldNumber) + 10; + } + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// fixed64 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeFixed64Size(int fieldNumber, ulong value) + { + return ComputeTagSize(fieldNumber) + LittleEndian64Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// fixed32 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeFixed32Size(int fieldNumber, uint value) + { + return ComputeTagSize(fieldNumber) + LittleEndian32Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// bool field, including the tag. + /// + public static int ComputeBoolSize(int fieldNumber, bool value) + { + return ComputeTagSize(fieldNumber) + 1; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// string field, including the tag. + /// + public static int ComputeStringSize(int fieldNumber, String value) + { + int byteArraySize = Encoding.UTF8.GetByteCount(value); + return ComputeTagSize(fieldNumber) + + ComputeRawVarint32Size((uint) byteArraySize) + + byteArraySize; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// group field, including the tag. + /// + public static int ComputeGroupSize(int fieldNumber, IMessageLite value) + { + return ComputeTagSize(fieldNumber)*2 + value.SerializedSize; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// group field represented by an UnknownFieldSet, including the tag. + /// + [Obsolete] + public static int ComputeUnknownGroupSize(int fieldNumber, + IMessageLite value) + { + return ComputeTagSize(fieldNumber)*2 + value.SerializedSize; + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// embedded message field, including the tag. + /// + public static int ComputeMessageSize(int fieldNumber, IMessageLite value) + { + int size = value.SerializedSize; + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) size) + size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// bytes field, including the tag. + /// + public static int ComputeBytesSize(int fieldNumber, ByteString value) + { + return ComputeTagSize(fieldNumber) + + ComputeRawVarint32Size((uint) value.Length) + + value.Length; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// uint32 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeUInt32Size(int fieldNumber, uint value) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(value); + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// enum field, including the tag. The caller is responsible for + /// converting the enum value to its numeric value. + /// + public static int ComputeEnumSize(int fieldNumber, int value) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sfixed32 field, including the tag. + /// + public static int ComputeSFixed32Size(int fieldNumber, int value) + { + return ComputeTagSize(fieldNumber) + LittleEndian32Size; + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sfixed64 field, including the tag. + /// + public static int ComputeSFixed64Size(int fieldNumber, long value) + { + return ComputeTagSize(fieldNumber) + LittleEndian64Size; + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sint32 field, including the tag. + /// + public static int ComputeSInt32Size(int fieldNumber, int value) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(EncodeZigZag32(value)); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sint64 field, including the tag. + /// + public static int ComputeSInt64Size(int fieldNumber, long value) + { + return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(EncodeZigZag64(value)); + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// double field, including the tag. + /// + public static int ComputeDoubleSizeNoTag(double value) + { + return LittleEndian64Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// float field, including the tag. + /// + public static int ComputeFloatSizeNoTag(float value) + { + return LittleEndian32Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// uint64 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeUInt64SizeNoTag(ulong value) + { + return ComputeRawVarint64Size(value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// int64 field, including the tag. + /// + public static int ComputeInt64SizeNoTag(long value) + { + return ComputeRawVarint64Size((ulong) value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// int32 field, including the tag. + /// + public static int ComputeInt32SizeNoTag(int value) + { + if (value >= 0) + { + return ComputeRawVarint32Size((uint) value); + } + else + { + // Must sign-extend. + return 10; + } + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// fixed64 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeFixed64SizeNoTag(ulong value) + { + return LittleEndian64Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// fixed32 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeFixed32SizeNoTag(uint value) + { + return LittleEndian32Size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// bool field, including the tag. + /// + public static int ComputeBoolSizeNoTag(bool value) + { + return 1; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// string field, including the tag. + /// + public static int ComputeStringSizeNoTag(String value) + { + int byteArraySize = Encoding.UTF8.GetByteCount(value); + return ComputeRawVarint32Size((uint) byteArraySize) + + byteArraySize; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// group field, including the tag. + /// + public static int ComputeGroupSizeNoTag(IMessageLite value) + { + return value.SerializedSize; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// group field represented by an UnknownFieldSet, including the tag. + /// + [Obsolete] + public static int ComputeUnknownGroupSizeNoTag(IMessageLite value) + { + return value.SerializedSize; + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// embedded message field, including the tag. + /// + public static int ComputeMessageSizeNoTag(IMessageLite value) + { + int size = value.SerializedSize; + return ComputeRawVarint32Size((uint) size) + size; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// bytes field, including the tag. + /// + public static int ComputeBytesSizeNoTag(ByteString value) + { + return ComputeRawVarint32Size((uint) value.Length) + + value.Length; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// uint32 field, including the tag. + /// + [CLSCompliant(false)] + public static int ComputeUInt32SizeNoTag(uint value) + { + return ComputeRawVarint32Size(value); + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// enum field, including the tag. The caller is responsible for + /// converting the enum value to its numeric value. + /// + public static int ComputeEnumSizeNoTag(int value) + { + return ComputeRawVarint32Size((uint) value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sfixed32 field, including the tag. + /// + public static int ComputeSFixed32SizeNoTag(int value) + { + return LittleEndian32Size; + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sfixed64 field, including the tag. + /// + public static int ComputeSFixed64SizeNoTag(long value) + { + return LittleEndian64Size; + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sint32 field, including the tag. + /// + public static int ComputeSInt32SizeNoTag(int value) + { + return ComputeRawVarint32Size(EncodeZigZag32(value)); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// sint64 field, including the tag. + /// + public static int ComputeSInt64SizeNoTag(long value) + { + return ComputeRawVarint64Size(EncodeZigZag64(value)); + } + + /* + * Compute the number of bytes that would be needed to encode a + * MessageSet extension to the stream. For historical reasons, + * the wire format differs from normal fields. + */ + + /// + /// Compute the number of bytes that would be needed to encode a + /// MessageSet extension to the stream. For historical reasons, + /// the wire format differs from normal fields. + /// + public static int ComputeMessageSetExtensionSize(int fieldNumber, IMessageLite value) + { + return ComputeTagSize(WireFormat.MessageSetField.Item)*2 + + ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) + + ComputeMessageSize(WireFormat.MessageSetField.Message, value); + } + + /// + /// Compute the number of bytes that would be needed to encode an + /// unparsed MessageSet extension field to the stream. For + /// historical reasons, the wire format differs from normal fields. + /// + public static int ComputeRawMessageSetExtensionSize(int fieldNumber, ByteString value) + { + return ComputeTagSize(WireFormat.MessageSetField.Item)*2 + + ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) + + ComputeBytesSize(WireFormat.MessageSetField.Message, value); + } + + /// + /// Compute the number of bytes that would be needed to encode a varint. + /// + [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; + return 5; + } + + /// + /// Compute the number of bytes that would be needed to encode a varint. + /// + [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; + return 10; + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// field of arbitrary type, including the tag, to the stream. + /// + public static int ComputeFieldSize(FieldType fieldType, int fieldNumber, Object value) + { + switch (fieldType) + { + case FieldType.Double: + return ComputeDoubleSize(fieldNumber, (double) value); + case FieldType.Float: + return ComputeFloatSize(fieldNumber, (float) value); + case FieldType.Int64: + return ComputeInt64Size(fieldNumber, (long) value); + case FieldType.UInt64: + return ComputeUInt64Size(fieldNumber, (ulong) value); + case FieldType.Int32: + return ComputeInt32Size(fieldNumber, (int) value); + case FieldType.Fixed64: + return ComputeFixed64Size(fieldNumber, (ulong) value); + case FieldType.Fixed32: + return ComputeFixed32Size(fieldNumber, (uint) value); + case FieldType.Bool: + return ComputeBoolSize(fieldNumber, (bool) value); + case FieldType.String: + return ComputeStringSize(fieldNumber, (string) value); + case FieldType.Group: + return ComputeGroupSize(fieldNumber, (IMessageLite) value); + case FieldType.Message: + return ComputeMessageSize(fieldNumber, (IMessageLite) value); + case FieldType.Bytes: + return ComputeBytesSize(fieldNumber, (ByteString) value); + case FieldType.UInt32: + return ComputeUInt32Size(fieldNumber, (uint) value); + case FieldType.SFixed32: + return ComputeSFixed32Size(fieldNumber, (int) value); + case FieldType.SFixed64: + return ComputeSFixed64Size(fieldNumber, (long) value); + case FieldType.SInt32: + return ComputeSInt32Size(fieldNumber, (int) value); + case FieldType.SInt64: + return ComputeSInt64Size(fieldNumber, (long) value); + case FieldType.Enum: + if (value is System.Enum) + return ComputeEnumSize(fieldNumber, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); + else + return ComputeEnumSize(fieldNumber, ((IEnumLite) value).Number); + default: + throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); + } + } + + /// + /// Compute the number of bytes that would be needed to encode a + /// field of arbitrary type, excluding the tag, to the stream. + /// + public static int ComputeFieldSizeNoTag(FieldType fieldType, Object value) + { + switch (fieldType) + { + case FieldType.Double: + return ComputeDoubleSizeNoTag((double) value); + case FieldType.Float: + return ComputeFloatSizeNoTag((float) value); + case FieldType.Int64: + return ComputeInt64SizeNoTag((long) value); + case FieldType.UInt64: + return ComputeUInt64SizeNoTag((ulong) value); + case FieldType.Int32: + return ComputeInt32SizeNoTag((int) value); + case FieldType.Fixed64: + return ComputeFixed64SizeNoTag((ulong) value); + case FieldType.Fixed32: + return ComputeFixed32SizeNoTag((uint) value); + case FieldType.Bool: + return ComputeBoolSizeNoTag((bool) value); + case FieldType.String: + return ComputeStringSizeNoTag((string) value); + case FieldType.Group: + return ComputeGroupSizeNoTag((IMessageLite) value); + case FieldType.Message: + return ComputeMessageSizeNoTag((IMessageLite) value); + case FieldType.Bytes: + return ComputeBytesSizeNoTag((ByteString) value); + case FieldType.UInt32: + return ComputeUInt32SizeNoTag((uint) value); + case FieldType.SFixed32: + return ComputeSFixed32SizeNoTag((int) value); + case FieldType.SFixed64: + return ComputeSFixed64SizeNoTag((long) value); + case FieldType.SInt32: + return ComputeSInt32SizeNoTag((int) value); + case FieldType.SInt64: + return ComputeSInt64SizeNoTag((long) value); + case FieldType.Enum: + if (value is System.Enum) + return ComputeEnumSizeNoTag(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); + else + return ComputeEnumSizeNoTag(((IEnumLite) value).Number); + default: + throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); + } + } + + /// + /// Compute the number of bytes that would be needed to encode a tag. + /// + public static int ComputeTagSize(int fieldNumber) + { + return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, 0)); + } + } +} \ No newline at end of file diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs index ee8a5dc6..7ebba9b0 100644 --- a/src/ProtocolBuffers/CodedOutputStream.cs +++ b/src/ProtocolBuffers/CodedOutputStream.cs @@ -55,7 +55,7 @@ namespace Google.ProtocolBuffers /// methods are taken from the protocol buffer type names, not .NET types. /// (Hence WriteFloat instead of WriteSingle, and WriteBool instead of WriteBoolean.) /// - public sealed partial class CodedOutputStream + public sealed partial class CodedOutputStream : ICodedOutputStream { /// /// The buffer size used by CreateInstance(Stream). @@ -408,9 +408,9 @@ namespace Google.ProtocolBuffers break; case FieldType.Enum: if(value is System.Enum) - WriteEnum(fieldNumber, fieldName, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture), value.ToString()); + WriteEnum(fieldNumber, fieldName, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture), null/*not used*/); else - WriteEnum(fieldNumber, fieldName, ((IEnumLite) value).Number, ((IEnumLite) value).Name); + WriteEnum(fieldNumber, fieldName, ((IEnumLite) value).Number, null/*not used*/); break; } } @@ -803,568 +803,6 @@ namespace Google.ProtocolBuffers } #endregion - - #region Size computations - - private const int LittleEndian64Size = 8; - private const int LittleEndian32Size = 4; - - /// - /// Compute the number of bytes that would be needed to encode a - /// double field, including the tag. - /// - public static int ComputeDoubleSize(int fieldNumber, double value) - { - return ComputeTagSize(fieldNumber) + LittleEndian64Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// float field, including the tag. - /// - public static int ComputeFloatSize(int fieldNumber, float value) - { - return ComputeTagSize(fieldNumber) + LittleEndian32Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// uint64 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeUInt64Size(int fieldNumber, ulong value) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// int64 field, including the tag. - /// - public static int ComputeInt64Size(int fieldNumber, long value) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size((ulong) value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// int32 field, including the tag. - /// - public static int ComputeInt32Size(int fieldNumber, int value) - { - if (value >= 0) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) value); - } - else - { - // Must sign-extend. - return ComputeTagSize(fieldNumber) + 10; - } - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// fixed64 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeFixed64Size(int fieldNumber, ulong value) - { - return ComputeTagSize(fieldNumber) + LittleEndian64Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// fixed32 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeFixed32Size(int fieldNumber, uint value) - { - return ComputeTagSize(fieldNumber) + LittleEndian32Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// bool field, including the tag. - /// - public static int ComputeBoolSize(int fieldNumber, bool value) - { - return ComputeTagSize(fieldNumber) + 1; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// string field, including the tag. - /// - public static int ComputeStringSize(int fieldNumber, String value) - { - int byteArraySize = Encoding.UTF8.GetByteCount(value); - return ComputeTagSize(fieldNumber) + - ComputeRawVarint32Size((uint) byteArraySize) + - byteArraySize; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// group field, including the tag. - /// - public static int ComputeGroupSize(int fieldNumber, IMessageLite value) - { - return ComputeTagSize(fieldNumber)*2 + value.SerializedSize; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// group field represented by an UnknownFieldSet, including the tag. - /// - [Obsolete] - public static int ComputeUnknownGroupSize(int fieldNumber, - IMessageLite value) - { - return ComputeTagSize(fieldNumber)*2 + value.SerializedSize; - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// embedded message field, including the tag. - /// - public static int ComputeMessageSize(int fieldNumber, IMessageLite value) - { - int size = value.SerializedSize; - return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) size) + size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// bytes field, including the tag. - /// - public static int ComputeBytesSize(int fieldNumber, ByteString value) - { - return ComputeTagSize(fieldNumber) + - ComputeRawVarint32Size((uint) value.Length) + - value.Length; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// uint32 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeUInt32Size(int fieldNumber, uint value) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(value); - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// enum field, including the tag. The caller is responsible for - /// converting the enum value to its numeric value. - /// - public static int ComputeEnumSize(int fieldNumber, int value) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint) value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sfixed32 field, including the tag. - /// - public static int ComputeSFixed32Size(int fieldNumber, int value) - { - return ComputeTagSize(fieldNumber) + LittleEndian32Size; - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sfixed64 field, including the tag. - /// - public static int ComputeSFixed64Size(int fieldNumber, long value) - { - return ComputeTagSize(fieldNumber) + LittleEndian64Size; - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sint32 field, including the tag. - /// - public static int ComputeSInt32Size(int fieldNumber, int value) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(EncodeZigZag32(value)); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sint64 field, including the tag. - /// - public static int ComputeSInt64Size(int fieldNumber, long value) - { - return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(EncodeZigZag64(value)); - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// double field, including the tag. - /// - public static int ComputeDoubleSizeNoTag(double value) - { - return LittleEndian64Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// float field, including the tag. - /// - public static int ComputeFloatSizeNoTag(float value) - { - return LittleEndian32Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// uint64 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeUInt64SizeNoTag(ulong value) - { - return ComputeRawVarint64Size(value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// int64 field, including the tag. - /// - public static int ComputeInt64SizeNoTag(long value) - { - return ComputeRawVarint64Size((ulong) value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// int32 field, including the tag. - /// - public static int ComputeInt32SizeNoTag(int value) - { - if (value >= 0) - { - return ComputeRawVarint32Size((uint) value); - } - else - { - // Must sign-extend. - return 10; - } - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// fixed64 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeFixed64SizeNoTag(ulong value) - { - return LittleEndian64Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// fixed32 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeFixed32SizeNoTag(uint value) - { - return LittleEndian32Size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// bool field, including the tag. - /// - public static int ComputeBoolSizeNoTag(bool value) - { - return 1; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// string field, including the tag. - /// - public static int ComputeStringSizeNoTag(String value) - { - int byteArraySize = Encoding.UTF8.GetByteCount(value); - return ComputeRawVarint32Size((uint) byteArraySize) + - byteArraySize; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// group field, including the tag. - /// - public static int ComputeGroupSizeNoTag(IMessageLite value) - { - return value.SerializedSize; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// group field represented by an UnknownFieldSet, including the tag. - /// - [Obsolete] - public static int ComputeUnknownGroupSizeNoTag(IMessageLite value) - { - return value.SerializedSize; - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// embedded message field, including the tag. - /// - public static int ComputeMessageSizeNoTag(IMessageLite value) - { - int size = value.SerializedSize; - return ComputeRawVarint32Size((uint) size) + size; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// bytes field, including the tag. - /// - public static int ComputeBytesSizeNoTag(ByteString value) - { - return ComputeRawVarint32Size((uint) value.Length) + - value.Length; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// uint32 field, including the tag. - /// - [CLSCompliant(false)] - public static int ComputeUInt32SizeNoTag(uint value) - { - return ComputeRawVarint32Size(value); - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// enum field, including the tag. The caller is responsible for - /// converting the enum value to its numeric value. - /// - public static int ComputeEnumSizeNoTag(int value) - { - return ComputeRawVarint32Size((uint) value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sfixed32 field, including the tag. - /// - public static int ComputeSFixed32SizeNoTag(int value) - { - return LittleEndian32Size; - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sfixed64 field, including the tag. - /// - public static int ComputeSFixed64SizeNoTag(long value) - { - return LittleEndian64Size; - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sint32 field, including the tag. - /// - public static int ComputeSInt32SizeNoTag(int value) - { - return ComputeRawVarint32Size(EncodeZigZag32(value)); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// sint64 field, including the tag. - /// - public static int ComputeSInt64SizeNoTag(long value) - { - return ComputeRawVarint64Size(EncodeZigZag64(value)); - } - - /* - * Compute the number of bytes that would be needed to encode a - * MessageSet extension to the stream. For historical reasons, - * the wire format differs from normal fields. - */ - - /// - /// Compute the number of bytes that would be needed to encode a - /// MessageSet extension to the stream. For historical reasons, - /// the wire format differs from normal fields. - /// - public static int ComputeMessageSetExtensionSize(int fieldNumber, IMessageLite value) - { - return ComputeTagSize(WireFormat.MessageSetField.Item)*2 + - ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) + - ComputeMessageSize(WireFormat.MessageSetField.Message, value); - } - - /// - /// Compute the number of bytes that would be needed to encode an - /// unparsed MessageSet extension field to the stream. For - /// historical reasons, the wire format differs from normal fields. - /// - public static int ComputeRawMessageSetExtensionSize(int fieldNumber, ByteString value) - { - return ComputeTagSize(WireFormat.MessageSetField.Item)*2 + - ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) + - ComputeBytesSize(WireFormat.MessageSetField.Message, value); - } - - /// - /// Compute the number of bytes that would be needed to encode a varint. - /// - [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; - return 5; - } - - /// - /// Compute the number of bytes that would be needed to encode a varint. - /// - [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; - return 10; - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// field of arbitrary type, including the tag, to the stream. - /// - public static int ComputeFieldSize(FieldType fieldType, int fieldNumber, Object value) - { - switch (fieldType) - { - case FieldType.Double: - return ComputeDoubleSize(fieldNumber, (double) value); - case FieldType.Float: - return ComputeFloatSize(fieldNumber, (float) value); - case FieldType.Int64: - return ComputeInt64Size(fieldNumber, (long) value); - case FieldType.UInt64: - return ComputeUInt64Size(fieldNumber, (ulong) value); - case FieldType.Int32: - return ComputeInt32Size(fieldNumber, (int) value); - case FieldType.Fixed64: - return ComputeFixed64Size(fieldNumber, (ulong) value); - case FieldType.Fixed32: - return ComputeFixed32Size(fieldNumber, (uint) value); - case FieldType.Bool: - return ComputeBoolSize(fieldNumber, (bool) value); - case FieldType.String: - return ComputeStringSize(fieldNumber, (string) value); - case FieldType.Group: - return ComputeGroupSize(fieldNumber, (IMessageLite) value); - case FieldType.Message: - return ComputeMessageSize(fieldNumber, (IMessageLite) value); - case FieldType.Bytes: - return ComputeBytesSize(fieldNumber, (ByteString) value); - case FieldType.UInt32: - return ComputeUInt32Size(fieldNumber, (uint) value); - case FieldType.SFixed32: - return ComputeSFixed32Size(fieldNumber, (int) value); - case FieldType.SFixed64: - return ComputeSFixed64Size(fieldNumber, (long) value); - case FieldType.SInt32: - return ComputeSInt32Size(fieldNumber, (int) value); - case FieldType.SInt64: - return ComputeSInt64Size(fieldNumber, (long) value); - case FieldType.Enum: - if (value is System.Enum) - return ComputeEnumSize(fieldNumber, ((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); - else - return ComputeEnumSize(fieldNumber, ((IEnumLite) value).Number); - default: - throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); - } - } - - /// - /// Compute the number of bytes that would be needed to encode a - /// field of arbitrary type, excluding the tag, to the stream. - /// - public static int ComputeFieldSizeNoTag(FieldType fieldType, Object value) - { - switch (fieldType) - { - case FieldType.Double: - return ComputeDoubleSizeNoTag((double) value); - case FieldType.Float: - return ComputeFloatSizeNoTag((float) value); - case FieldType.Int64: - return ComputeInt64SizeNoTag((long) value); - case FieldType.UInt64: - return ComputeUInt64SizeNoTag((ulong) value); - case FieldType.Int32: - return ComputeInt32SizeNoTag((int) value); - case FieldType.Fixed64: - return ComputeFixed64SizeNoTag((ulong) value); - case FieldType.Fixed32: - return ComputeFixed32SizeNoTag((uint) value); - case FieldType.Bool: - return ComputeBoolSizeNoTag((bool) value); - case FieldType.String: - return ComputeStringSizeNoTag((string) value); - case FieldType.Group: - return ComputeGroupSizeNoTag((IMessageLite) value); - case FieldType.Message: - return ComputeMessageSizeNoTag((IMessageLite) value); - case FieldType.Bytes: - return ComputeBytesSizeNoTag((ByteString) value); - case FieldType.UInt32: - return ComputeUInt32SizeNoTag((uint) value); - case FieldType.SFixed32: - return ComputeSFixed32SizeNoTag((int) value); - case FieldType.SFixed64: - return ComputeSFixed64SizeNoTag((long) value); - case FieldType.SInt32: - return ComputeSInt32SizeNoTag((int) value); - case FieldType.SInt64: - return ComputeSInt64SizeNoTag((long) value); - case FieldType.Enum: - if (value is System.Enum) - return ComputeEnumSizeNoTag(((IConvertible)value).ToInt32(CultureInfo.InvariantCulture)); - else - return ComputeEnumSizeNoTag(((IEnumLite) value).Number); - default: - throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); - } - } - - /// - /// Compute the number of bytes that would be needed to encode a tag. - /// - public static int ComputeTagSize(int fieldNumber) - { - return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, 0)); - } - - #endregion - /// /// Encode a 32-bit value with ZigZag encoding. /// diff --git a/src/ProtocolBuffers/ICodedOutputStream.cs b/src/ProtocolBuffers/ICodedOutputStream.cs new file mode 100644 index 00000000..fb290eb6 --- /dev/null +++ b/src/ProtocolBuffers/ICodedOutputStream.cs @@ -0,0 +1,84 @@ +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers +{ + public interface ICodedOutputStream + { + /// + /// Writes a double field value, including tag, to the stream. + /// + void WriteDouble(int fieldNumber, string fieldName, double value); + + /// + /// Writes a float field value, including tag, to the stream. + /// + void WriteFloat(int fieldNumber, string fieldName, float value); + + /// + /// Writes a uint64 field value, including tag, to the stream. + /// + [CLSCompliant(false)] + void WriteUInt64(int fieldNumber, string fieldName, ulong value); + + /// + /// Writes an int64 field value, including tag, to the stream. + /// + void WriteInt64(int fieldNumber, string fieldName, long value); + + /// + /// Writes an int32 field value, including tag, to the stream. + /// + void WriteInt32(int fieldNumber, string fieldName, int value); + + /// + /// Writes a fixed64 field value, including tag, to the stream. + /// + [CLSCompliant(false)] + void WriteFixed64(int fieldNumber, string fieldName, ulong value); + + /// + /// Writes a fixed32 field value, including tag, to the stream. + /// + [CLSCompliant(false)] + void WriteFixed32(int fieldNumber, string fieldName, uint value); + + /// + /// Writes a bool field value, including tag, to the stream. + /// + void WriteBool(int fieldNumber, string fieldName, bool value); + + /// + /// Writes a string field value, including tag, to the stream. + /// + void WriteString(int fieldNumber, string fieldName, string value); + + /// + /// Writes a group field value, including tag, to the stream. + /// + void WriteGroup(int fieldNumber, string fieldName, IMessageLite value); + + [Obsolete] + void WriteUnknownGroup(int fieldNumber, string fieldName, IMessageLite value); + + void WriteMessage(int fieldNumber, string fieldName, IMessageLite value); + void WriteBytes(int fieldNumber, string fieldName, ByteString value); + + [CLSCompliant(false)] + void WriteUInt32(int fieldNumber, string fieldName, uint value); + + void WriteEnum(int fieldNumber, string fieldName, int value, string textValue); + void WriteSFixed32(int fieldNumber, string fieldName, int value); + void WriteSFixed64(int fieldNumber, string fieldName, long value); + void WriteSInt32(int fieldNumber, string fieldName, int value); + void WriteSInt64(int fieldNumber, string fieldName, long value); + void WriteMessageSetExtension(int fieldNumber, string fieldName, IMessageLite value); + void WriteMessageArray(int fieldNumber, string fieldName, System.Collections.IEnumerable list); + void WriteGroupArray(int fieldNumber, string fieldName, System.Collections.IEnumerable list); + void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list); + void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list); + void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.IEnumerable list); + void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value); + void Flush(); + } +} \ No newline at end of file diff --git a/src/ProtocolBuffers/ProtocolBuffers.csproj b/src/ProtocolBuffers/ProtocolBuffers.csproj index cf3e8710..5928cac4 100644 --- a/src/ProtocolBuffers/ProtocolBuffers.csproj +++ b/src/ProtocolBuffers/ProtocolBuffers.csproj @@ -103,6 +103,7 @@ + @@ -163,6 +164,7 @@ Code + -- cgit v1.2.3