Reformatted to include braces
diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs
index 25fc0ea..59490df 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 @@
[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 @@
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 @@
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 @@
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 @@
else
WriteRawBytes(rawBytes, 0, 8);
#else
- WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value));
+ WriteRawLittleEndian64((ulong) BitConverter.DoubleToInt64Bits(value));
#endif
}
@@ -508,7 +523,9 @@
{
byte[] rawBytes = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
+ {
ByteArray.Reverse(rawBytes);
+ }
if (limit - position >= 4)
{
@@ -518,7 +535,9 @@
buffer[position++] = rawBytes[3];
}
else
+ {
WriteRawBytes(rawBytes, 0, 4);
+ }
}
/// <summary>
@@ -535,7 +554,7 @@
/// </summary>
public void WriteInt64NoTag(long value)
{
- WriteRawVarint64((ulong)value);
+ WriteRawVarint64((ulong) value);
}
/// <summary>
@@ -545,12 +564,12 @@
{
if (value >= 0)
{
- WriteRawVarint32((uint)value);
+ WriteRawVarint32((uint) value);
}
else
{
// Must sign-extend.
- WriteRawVarint64((ulong)value);
+ WriteRawVarint64((ulong) value);
}
}
@@ -577,7 +596,7 @@
/// </summary>
public void WriteBoolNoTag(bool value)
{
- WriteRawByte(value ? (byte)1 : (byte)0);
+ WriteRawByte(value ? (byte) 1 : (byte) 0);
}
/// <summary>
@@ -588,7 +607,7 @@
// 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 @@
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 @@
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 @@
#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<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : IMessageLite
{
foreach (IMessageLite value in list)
+ {
WriteGroup(fieldNumber, fieldName, value);
+ }
}
public void WriteMessageArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : IMessageLite
{
foreach (IMessageLite value in list)
+ {
WriteMessage(fieldNumber, fieldName, value);
+ }
}
public void WriteStringArray(int fieldNumber, string fieldName, IEnumerable<string> list)
{
foreach (var value in list)
+ {
WriteString(fieldNumber, fieldName, value);
+ }
}
public void WriteBytesArray(int fieldNumber, string fieldName, IEnumerable<ByteString> list)
{
foreach (var value in list)
+ {
WriteBytes(fieldNumber, fieldName, value);
+ }
}
public void WriteBoolArray(int fieldNumber, string fieldName, IEnumerable<bool> list)
{
foreach (var value in list)
+ {
WriteBool(fieldNumber, fieldName, value);
+ }
}
public void WriteInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
{
foreach (var value in list)
+ {
WriteInt32(fieldNumber, fieldName, value);
+ }
}
public void WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
{
foreach (var value in list)
+ {
WriteSInt32(fieldNumber, fieldName, value);
+ }
}
public void WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable<uint> list)
{
foreach (var value in list)
+ {
WriteUInt32(fieldNumber, fieldName, value);
+ }
}
public void WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable<uint> list)
{
foreach (var value in list)
+ {
WriteFixed32(fieldNumber, fieldName, value);
+ }
}
public void WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
{
foreach (var value in list)
+ {
WriteSFixed32(fieldNumber, fieldName, value);
+ }
}
public void WriteInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
{
foreach (var value in list)
+ {
WriteInt64(fieldNumber, fieldName, value);
+ }
}
public void WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
{
foreach (var value in list)
+ {
WriteSInt64(fieldNumber, fieldName, value);
+ }
}
public void WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list)
{
foreach (var value in list)
+ {
WriteUInt64(fieldNumber, fieldName, value);
+ }
}
public void WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list)
{
foreach (var value in list)
+ {
WriteFixed64(fieldNumber, fieldName, value);
+ }
}
public void WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
{
foreach (var value in list)
+ {
WriteSFixed64(fieldNumber, fieldName, value);
+ }
}
public void WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable<double> list)
{
foreach (var value in list)
+ {
WriteDouble(fieldNumber, fieldName, value);
+ }
}
public void WriteFloatArray(int fieldNumber, string fieldName, IEnumerable<float> list)
{
foreach (var value in list)
+ {
WriteFloat(fieldNumber, fieldName, value);
+ }
}
[CLSCompliant(false)]
@@ -772,13 +827,17 @@
{
if (list is ICastArray)
{
- foreach (int value in ((ICastArray)list).CastArray<int>())
+ foreach (int value in ((ICastArray) list).CastArray<int>())
+ {
WriteEnum(fieldNumber, fieldName, value, null /*unused*/);
+ }
}
else
{
foreach (object value in list)
+ {
WriteEnum(fieldNumber, fieldName, (int) value, null /*unused*/);
+ }
}
}
@@ -786,155 +845,202 @@
#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<T>(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<T> 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<T>(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<T> list)
+ public void WritePackedMessageArray<T>(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<T> 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<string> list)
+ public void WritePackedStringArray(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<string> 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<ByteString> list)
+ public void WritePackedBytesArray(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<ByteString> 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<bool> 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<int> 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<int> 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<uint> 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<uint> list)
+ public void WritePackedFixed32Array(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<uint> 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<int> list)
+ public void WritePackedSFixed32Array(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<int> 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<long> 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<long> 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<ulong> list)
+ public void WritePackedUInt64Array(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<ulong> 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<ulong> list)
+ public void WritePackedFixed64Array(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<ulong> 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<long> list)
+ public void WritePackedSFixed64Array(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<long> 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<double> list)
+ public void WritePackedDoubleArray(int fieldNumber, string fieldName, int calculatedSize,
+ IEnumerable<double> 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<float> 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 @@
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<int>())
+ foreach (int value in ((ICastArray) list).CastArray<int>())
+ {
WriteEnumNoTag(value);
+ }
}
else
{
foreach (object value in list)
- WriteEnumNoTag((int)value);
+ {
+ WriteEnumNoTag((int) value);
+ }
}
}
@@ -986,6 +1096,7 @@
}
}
#endif
+
/// <summary>
/// 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 @@
#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 @@
#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 @@
}
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 @@
}
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 @@
}
#endregion
+
/// <summary>
/// Encode a 32-bit value with ZigZag encoding.
/// </summary>
