| public static BlockCopy ( byte from, int fromIndex, byte to, int toIndex, int count ) : void | ||
| from | byte | |
| fromIndex | int | |
| to | byte | |
| toIndex | int | |
| count | int | |
| return | void | |
// Token: 0x06003274 RID: 12916 RVA: 0x00126FC8 File Offset: 0x001253C8
void IExtension.EndAppend(Stream stream, bool commit)
{
try
{
int num;
if (commit && (num = (int)stream.Length) > 0)
{
MemoryStream memoryStream = (MemoryStream)stream;
if (this.buffer == null)
{
this.buffer = memoryStream.ToArray();
}
else
{
int num2 = this.buffer.Length;
byte[] to = new byte[num2 + num];
Helpers.BlockCopy(this.buffer, 0, to, 0, num2);
Helpers.BlockCopy(Helpers.GetBuffer(memoryStream), 0, to, num2, num);
this.buffer = to;
}
}
}
finally
{
if (stream != null)
{
((IDisposable)stream).Dispose();
}
}
}
internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
Helpers.DebugAssert(buffer != null);
Helpers.DebugAssert(toFitAtLeastBytes > buffer.Length);
Helpers.DebugAssert(copyFromIndex >= 0);
Helpers.DebugAssert(copyBytes >= 0);
// try doubling, else match
int newLength = buffer.Length * 2;
if (newLength < toFitAtLeastBytes)
{
newLength = toFitAtLeastBytes;
}
byte[] newBuffer = new byte[newLength];
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, newBuffer, 0, copyBytes);
}
if (buffer.Length == BufferPool.BufferLength)
{
BufferPool.ReleaseBufferToPool(ref buffer);
}
buffer = newBuffer;
}
/// <summary>
/// Writes a string to the stream; supported wire-types: String
/// </summary>
public static void WriteString(string value, ProtoWriter writer)
{
if (writer.wireType != WireType.String)
{
throw CreateException(writer);
}
if (value == null)
{
throw new ArgumentNullException("value"); // written header; now what?
}
int len = value.Length;
if (len == 0)
{
WriteUInt32Variant(0, writer);
writer.wireType = WireType.None;
return; // just a header
}
#if MF
byte[] bytes = encoding.GetBytes(value);
int actual = bytes.Length;
writer.WriteUInt32Variant((uint)actual);
writer.Ensure(actual);
Helpers.BlockCopy(bytes, 0, writer.ioBuffer, writer.ioIndex, actual);
#else
int predicted = encoding.GetByteCount(value);
WriteUInt32Variant((uint)predicted, writer);
DemandSpace(predicted, writer);
int actual = encoding.GetBytes(value, 0, value.Length, writer.ioBuffer, writer.ioIndex);
Helpers.DebugAssert(predicted == actual);
#endif
IncrementedAndReset(actual, writer);
}
void IExtension.EndAppend(Stream stream, bool commit)
{
using (stream)
{
int num;
if (commit && (num = (int)stream.Length) > 0)
{
using (MemoryStream memoryStream = (MemoryStream)stream)
{
if (buffer == null)
{
buffer = memoryStream.ToArray();
}
else
{
int num2 = buffer.Length;
byte[] to = new byte[num2 + num];
Helpers.BlockCopy(buffer, 0, to, 0, num2);
Helpers.BlockCopy(memoryStream.GetBuffer(), 0, to, num2, num);
buffer = to;
}
}
}
}
}
internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
Helpers.DebugAssert(buffer != null);
Helpers.DebugAssert(toFitAtLeastBytes > buffer.Length);
Helpers.DebugAssert(copyFromIndex >= 0);
Helpers.DebugAssert(copyBytes >= 0);
// try doubling, else match
int newLength = buffer.Length * 2;
if (newLength < toFitAtLeastBytes)
{
newLength = toFitAtLeastBytes;
}
try
{
if (copyBytes == 0)
{
BufferPool.ReleaseBufferToPool(ref buffer); // No need to copy, we can release immediately
}
byte[] newBuffer = GetCachedBuffer(toFitAtLeastBytes);
if (newBuffer == null)
{
newBuffer = new byte[newLength];
}
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, newBuffer, 0, copyBytes);
BufferPool.ReleaseBufferToPool(ref buffer);
}
buffer = newBuffer;
}
catch (OutOfMemoryException)
{
// Low memory situation: flush existing buffers, save current to disk, allocate new one and read data back
string tempPath = Path.GetTempFileName();
try
{
Flush();
File.WriteAllBytes(tempPath, buffer); // Write the current buffer to disk to be able to release the current buffer
buffer = null;
GC.Collect();
GC.WaitForPendingFinalizers();
buffer = new byte[(newLength + toFitAtLeastBytes) / 2]; // A bit more conservative resizing
using (FileStream stream = File.OpenRead(tempPath))
{
stream.Read(buffer, 0, copyBytes); // Read data back from disk
}
}
finally
{
try { File.Delete(tempPath); } // Remove temporary file
catch { }
}
}
}
internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
Helpers.DebugAssert(buffer != null);
Helpers.DebugAssert(toFitAtLeastBytes > buffer.Length);
Helpers.DebugAssert(copyFromIndex >= 0);
Helpers.DebugAssert(copyBytes >= 0);
int newLength = buffer.Length * 2;
if (newLength < 0)
{
newLength = MaxByteArraySize;
}
if (newLength < toFitAtLeastBytes)
{
newLength = toFitAtLeastBytes;
}
if (copyBytes == 0)
{
ReleaseBufferToPool(ref buffer);
}
var newBuffer = GetCachedBuffer(toFitAtLeastBytes) ?? new byte[newLength];
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, newBuffer, 0, copyBytes);
ReleaseBufferToPool(ref buffer);
}
buffer = newBuffer;
}
void ProtoBuf.IExtension.EndAppend(Stream stream, bool commit)
{
using (stream)
{
if (commit)
{
int length = (int)stream.Length;
int num = length;
if (length > 0)
{
MemoryStream memoryStream = (MemoryStream)stream;
if (this.buffer != null)
{
int length1 = (int)this.buffer.Length;
byte[] numArray = new byte[length1 + num];
Helpers.BlockCopy(this.buffer, 0, numArray, 0, length1);
Helpers.BlockCopy(memoryStream.GetBuffer(), 0, numArray, length1, num);
this.buffer = numArray;
}
else
{
this.buffer = memoryStream.ToArray();
}
}
}
}
}
void IExtension.EndAppend(Stream stream, bool commit)
{
using (stream)
{
int len;
if (commit && (len = (int)stream.Length) > 0)
{
MemoryStream ms = (MemoryStream)stream;
if (buffer == null)
{ // allocate new buffer
buffer = ms.ToArray();
}
else
{ // resize and copy the data
// note: Array.Resize not available on CF
int offset = buffer.Length;
byte[] tmp = new byte[offset + len];
Helpers.BlockCopy(buffer, 0, tmp, 0, offset);
Helpers.BlockCopy(ms.GetBuffer(), 0, tmp, offset, len);
buffer = tmp;
}
}
}
}
public static byte[] AppendBytes(byte[] value, ProtoReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
WireType wireType = reader.wireType;
if (wireType == WireType.String)
{
int num = (int)reader.ReadUInt32Variant(trimNegative: false);
reader.wireType = WireType.None;
if (num == 0)
{
if (value != null)
{
return(value);
}
return(EmptyBlob);
}
int num2;
if (value == null || value.Length == 0)
{
num2 = 0;
value = new byte[num];
}
else
{
num2 = value.Length;
byte[] array = new byte[value.Length + num];
Helpers.BlockCopy(value, 0, array, 0, value.Length);
value = array;
}
reader.position += num;
while (num > reader.available)
{
if (reader.available > 0)
{
Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, num2, reader.available);
num -= reader.available;
num2 += reader.available;
reader.ioIndex = (reader.available = 0);
}
int num3 = (num > reader.ioBuffer.Length) ? reader.ioBuffer.Length : num;
if (num3 > 0)
{
reader.Ensure(num3, strict: true);
}
}
if (num > 0)
{
Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, num2, num);
reader.ioIndex += num;
reader.available -= num;
}
return(value);
}
throw reader.CreateWireTypeException();
}
/// <summary>
/// Writes a byte-array to the stream; supported wire-types: String
/// </summary>
public static void WriteBytes(byte[] data, int offset, int length, ProtoWriter writer)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
switch (writer.wireType)
{
case WireType.Fixed32:
if (length != 4)
{
throw new ArgumentException("length");
}
goto CopyFixedLength; // ugly but effective
case WireType.Fixed64:
if (length != 8)
{
throw new ArgumentException("length");
}
goto CopyFixedLength; // ugly but effective
case WireType.String:
WriteUInt32Variant((uint)length, writer);
writer.wireType = WireType.None;
if (length == 0)
{
return;
}
if (writer.flushLock != 0 || length <= writer.ioBuffer.Length) // write to the buffer
{
goto CopyFixedLength; // ugly but effective
}
// writing data that is bigger than the buffer (and the buffer
// isn't currently locked due to a sub-object needing the size backfilled)
Flush(writer); // commit any existing data from the buffer
// now just write directly to the underlying stream
#if OPTIMIZATION_NETWORK
writer._destBuf.In(data, (UInt32)offset, (UInt32)length);
#else
writer.dest.Write(data, offset, length);
#endif
writer.position += length; // since we've flushed offset etc is 0, and remains
// zero since we're writing directly to the stream
return;
}
throw CreateException(writer);
CopyFixedLength: // no point duplicating this lots of times, and don't really want another stackframe
DemandSpace(length, writer);
Helpers.BlockCopy(data, offset, writer.ioBuffer, writer.ioIndex, length);
IncrementedAndReset(length, writer);
}
public static byte[] AppendBytes(byte[] value, ProtoReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
WireType wireType = reader.wireType;
if (wireType != WireType.String)
{
throw reader.CreateWireTypeException();
}
int i = (int)reader.ReadUInt32Variant(false);
reader.wireType = WireType.None;
if (i == 0)
{
return((value != null) ? value : ProtoReader.EmptyBlob);
}
int num;
if (value == null || value.Length == 0)
{
num = 0;
value = new byte[i];
}
else
{
num = value.Length;
byte[] array = new byte[value.Length + i];
Helpers.BlockCopy(value, 0, array, 0, value.Length);
value = array;
}
reader.position += i;
while (i > reader.available)
{
if (reader.available > 0)
{
Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, num, reader.available);
i -= reader.available;
num += reader.available;
reader.ioIndex = (reader.available = 0);
}
int num2 = (i <= reader.ioBuffer.Length) ? i : reader.ioBuffer.Length;
if (num2 > 0)
{
reader.Ensure(num2, true);
}
}
if (i > 0)
{
Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, num, i);
reader.ioIndex += i;
reader.available -= i;
}
return(value);
}
/// <summary>
/// Reads a byte-sequence from the stream, appending them to an existing byte-sequence (which can be null); supported wire-types: String
/// </summary>
public static byte[] AppendBytes(byte[] value, ProtoReader reader)
{
switch (reader.wireType)
{
case WireType.String:
int len = (int)reader.ReadUInt32Variant(false);
reader.wireType = WireType.None;
if (len == 0)
{
return(value);
}
int offset;
if (value == null || value.Length == 0)
{
offset = 0;
value = new byte[len];
}
else
{
offset = value.Length;
byte[] tmp = new byte[value.Length + len];
Helpers.BlockCopy(value, 0, tmp, 0, value.Length);
value = tmp;
}
// value is now sized with the final length, and (if necessary)
// contains the old data up to "offset"
reader.position += len; // assume success
while (len > reader.available)
{
if (reader.available > 0)
{
// copy what we *do* have
Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, offset, reader.available);
len -= reader.available;
offset += reader.available;
reader.ioIndex = reader.available = 0; // we've drained the buffer
}
// now refill the buffer (without overflowing it)
int count = len > reader.ioBuffer.Length ? reader.ioBuffer.Length : len;
if (count > 0)
{
reader.Ensure(count, true);
}
}
// at this point, we know that len <= available
if (len > 0)
{ // still need data, but we have enough buffered
Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, offset, len);
reader.ioIndex += len;
reader.available -= len;
}
return(value);
default:
throw reader.CreateException();
}
}
public static void WriteBytes(byte[] data, int offset, int length, ProtoWriter writer)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
switch (writer.wireType)
{
case WireType.Fixed32:
if (length == 4)
{
break;
}
throw new ArgumentException("length");
case WireType.Fixed64:
if (length == 8)
{
break;
}
throw new ArgumentException("length");
case WireType.String:
WriteUInt32Variant((uint)length, writer);
writer.wireType = WireType.None;
if (length != 0)
{
if (writer.flushLock != 0)
{
break;
}
if (length <= writer.ioBuffer.Length)
{
break;
}
Flush(writer);
writer.dest.Write(data, offset, length);
writer.position += length;
}
return;
default:
throw CreateException(writer);
}
DemandSpace(length, writer);
Helpers.BlockCopy(data, offset, writer.ioBuffer, writer.ioIndex, length);
IncrementedAndReset(length, writer);
}
void IExtension.EndAppend(Stream stream, bool commit)
{
using (stream)
{
int len;
if (commit && (len = (int)stream.Length) > 0)
{
MemoryStream ms = (MemoryStream)stream;
if (buffer == null)
{ // allocate new buffer
buffer = ms.ToArray();
}
else
{ // resize and copy the data
// note: Array.Resize not available on CF
int offset = buffer.Length;
byte[] tmp = new byte[offset + len];
Helpers.BlockCopy(buffer, 0, tmp, 0, offset);
#if PORTABLE || WINRT // no GetBuffer() - fine, we'll use Read instead
int bytesRead;
long oldPos = ms.Position;
ms.Position = 0;
while (len > 0 && (bytesRead = ms.Read(tmp, offset, len)) > 0)
{
len -= bytesRead;
offset += bytesRead;
}
if (len != 0)
{
throw new EndOfStreamException();
}
ms.Position = oldPos;
#elif DNXCORE50
ArraySegment <byte> segment;
if (ms.TryGetBuffer(out segment))
{
Helpers.BlockCopy(segment.Array, segment.Offset, tmp, offset, len);
}
else
{
throw new InvalidOperationException("Could not obtain underlying MemoryStream buffer");
}
#else
Helpers.BlockCopy(ms.GetBuffer(), 0, tmp, offset, len);
#endif
buffer = tmp;
}
}
}
}
public static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
Helpers.DebugAssert(buffer != null);
Helpers.DebugAssert(toFitAtLeastBytes > buffer.Length);
Helpers.DebugAssert(copyFromIndex >= 0);
Helpers.DebugAssert(copyBytes >= 0);
byte[] newBuffer = GetBuffer(toFitAtLeastBytes);
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, newBuffer, 0, copyBytes);
}
ReleaseBufferToPool(ref buffer);
buffer = newBuffer;
}
// Token: 0x060034C3 RID: 13507 RVA: 0x001320A0 File Offset: 0x001304A0
public static void WriteBytes(byte[] data, int offset, int length, ProtoWriter writer)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
WireType wireType = writer.wireType;
if (wireType != WireType.Fixed32)
{
if (wireType != WireType.Fixed64)
{
if (wireType != WireType.String)
{
throw ProtoWriter.CreateException(writer);
}
ProtoWriter.WriteUInt32Variant((uint)length, writer);
writer.wireType = WireType.None;
if (length == 0)
{
return;
}
if (writer.flushLock == 0 && length > writer.ioBuffer.Length)
{
ProtoWriter.Flush(writer);
writer.dest.Write(data, offset, length);
writer.position += length;
return;
}
}
else if (length != 8)
{
throw new ArgumentException("length");
}
}
else if (length != 4)
{
throw new ArgumentException("length");
}
ProtoWriter.DemandSpace(length, writer);
Helpers.BlockCopy(data, offset, writer.ioBuffer, writer.ioIndex, length);
ProtoWriter.IncrementedAndReset(length, writer);
}
internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
int length = (int)buffer.Length * 2;
if (length < toFitAtLeastBytes)
{
length = toFitAtLeastBytes;
}
byte[] numArray = new byte[length];
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, numArray, 0, copyBytes);
}
if ((int)buffer.Length == 1024)
{
BufferPool.ReleaseBufferToPool(ref buffer);
}
buffer = numArray;
}
internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
int num = buffer.Length * 2;
if (num < toFitAtLeastBytes)
{
num = toFitAtLeastBytes;
}
byte[] array = new byte[num];
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, array, 0, copyBytes);
}
if (buffer.Length == 1024)
{
BufferPool.ReleaseBufferToPool(ref buffer);
}
buffer = array;
}
internal void Ensure(int count, bool strict)
{
if (count > ioBuffer.Length)
{
BufferPool.ResizeAndFlushLeft(ref ioBuffer, count, ioIndex, available);
ioIndex = 0;
}
else if (ioIndex + count >= ioBuffer.Length)
{
Helpers.BlockCopy(ioBuffer, ioIndex, ioBuffer, 0, available);
ioIndex = 0;
}
count -= available;
int num = ioIndex + available;
int num2 = ioBuffer.Length - num;
if (isFixedLength && dataRemaining < num2)
{
num2 = dataRemaining;
}
int num3;
while (count > 0 && num2 > 0 && (num3 = source.Read(ioBuffer, num, num2)) > 0)
{
available += num3;
count -= num3;
num2 -= num3;
num += num3;
if (isFixedLength)
{
dataRemaining -= num3;
}
}
if (!strict)
{
return;
}
if (count <= 0)
{
return;
}
throw EoF(this);
}
internal void Ensure(int count, bool strict)
{
Helpers.DebugAssert(available <= count, "Asking for data without checking first");
if (count > ioBuffer.Length)
{
BufferPool.ResizeAndFlushLeft(ref ioBuffer, count, ioIndex, available);
ioIndex = 0;
}
else if (ioIndex + count >= ioBuffer.Length)
{
// need to shift the buffer data to the left to make space
Helpers.BlockCopy(ioBuffer, ioIndex, ioBuffer, 0, available);
ioIndex = 0;
}
count -= available;
int writePos = ioIndex + available, bytesRead;
int canRead = ioBuffer.Length - writePos;
if (isFixedLength)
{ // throttle it if needed
if (dataRemaining < canRead)
{
canRead = dataRemaining;
}
}
while (count > 0 && (bytesRead = source.Read(ioBuffer, writePos, canRead)) > 0)
{
available += bytesRead;
count -= bytesRead;
canRead -= bytesRead;
writePos += bytesRead;
if (isFixedLength)
{
dataRemaining -= bytesRead;
}
}
if (strict && count > 0)
{
throw EoF(this);
}
}
internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
{
Helpers.DebugAssert(buffer != null);
Helpers.DebugAssert(toFitAtLeastBytes > buffer.Length);
Helpers.DebugAssert(copyFromIndex >= 0);
Helpers.DebugAssert(copyBytes >= 0);
// try doubling, else match
int newLength = buffer.Length * 2;
if (newLength < 0)
{
newLength = MaxByteArraySize;
}
if (newLength < toFitAtLeastBytes)
{
newLength = toFitAtLeastBytes;
}
//byte[] newBuffer = new byte[newLength];
//if (copyBytes > 0)
//{
// Helpers.BlockCopy(buffer, copyFromIndex, newBuffer, 0, copyBytes);
//}
//if (buffer.Length == BufferPool.BufferLength)
//{
// BufferPool.ReleaseBufferToPool(ref buffer);
//}
//buffer = newBuffer;
byte[] newBuffer = BufferManager.TakeBuffer(newLength);
if (copyBytes > 0)
{
Helpers.BlockCopy(buffer, copyFromIndex, newBuffer, 0, copyBytes);
}
BufferManager.ReturnBuffer(buffer);
buffer = newBuffer;
}
internal void Ensure(int count, bool strict)
{
if (count > this.ioBuffer.Length)
{
BufferPool.ResizeAndFlushLeft(ref this.ioBuffer, count, this.ioIndex, this.available);
this.ioIndex = 0;
}
else if (this.ioIndex + count >= this.ioBuffer.Length)
{
Helpers.BlockCopy(this.ioBuffer, this.ioIndex, this.ioBuffer, 0, this.available);
this.ioIndex = 0;
}
count -= this.available;
int num = this.ioIndex + this.available;
int num2 = this.ioBuffer.Length - num;
if (this.isFixedLength && this.dataRemaining < num2)
{
num2 = this.dataRemaining;
}
int num3;
while (count > 0 && num2 > 0 && (num3 = this.source.Read(this.ioBuffer, num, num2)) > 0)
{
this.available += num3;
count -= num3;
num2 -= num3;
num += num3;
if (this.isFixedLength)
{
this.dataRemaining -= num3;
}
}
if (strict && count > 0)
{
throw ProtoReader.EoF(this);
}
}
/// <summary>
/// Reads a string from the stream (using UTF8); supported wire-types: String
/// </summary>
public string ReadString()
{
if (wireType == WireType.String)
{
int bytes = (int)ReadUInt32Variant(false);
if (bytes == 0)
{
return("");
}
if (available < bytes)
{
Ensure(bytes, true);
}
#if MF
byte[] tmp;
if (ioIndex == 0 && bytes == ioBuffer.Length)
{
// unlikely, but...
tmp = ioBuffer;
}
else
{
tmp = new byte[bytes];
Helpers.BlockCopy(ioBuffer, ioIndex, tmp, 0, bytes);
}
string s = new string(encoding.GetChars(tmp));
#else
string s = encoding.GetString(ioBuffer, ioIndex, bytes);
#endif
s = Intern(s);
available -= bytes;
position += bytes;
ioIndex += bytes;
return(s);
}
throw CreateException();
}
private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw CreateException(writer);
}
int value = token.value;
if (writer.depth <= 0)
{
throw CreateException(writer);
}
if (writer.depth-- > RecursionCheckDepth)
{
writer.PopRecursionStack();
}
writer.packedFieldNumber = 0; // ending the sub-item always wipes packed encoding
if (value < 0)
{ // group - very simple append
WriteHeaderCore(-value, WireType.EndGroup, writer);
writer.wireType = WireType.None;
return;
}
// so we're backfilling the length into an existing sequence
int len;
switch (style)
{
case PrefixStyle.Fixed32:
len = (int)((writer.ioIndex - value) - 4);
ProtoWriter.WriteInt32ToBuffer(len, writer.ioBuffer, value);
break;
case PrefixStyle.Fixed32BigEndian:
len = (int)((writer.ioIndex - value) - 4);
byte[] buffer = writer.ioBuffer;
ProtoWriter.WriteInt32ToBuffer(len, buffer, value);
// and swap the byte order
byte b = buffer[value];
buffer[value] = buffer[value + 3];
buffer[value + 3] = b;
b = buffer[value + 1];
buffer[value + 1] = buffer[value + 2];
buffer[value + 2] = b;
break;
case PrefixStyle.Base128:
// string - complicated because we only reserved one byte;
// if the prefix turns out to need more than this then
// we need to shuffle the existing data
len = (int)((writer.ioIndex - value) - 1);
int offset = 0;
uint tmp = (uint)len;
while ((tmp >>= 7) != 0)
{
offset++;
}
if (offset == 0)
{
writer.ioBuffer[value] = (byte)(len & 0x7F);
}
else
{
DemandSpace(offset, writer);
byte[] blob = writer.ioBuffer;
Helpers.BlockCopy(blob, value + 1, blob, value + 1 + offset, len);
tmp = (uint)len;
do
{
blob[value++] = (byte)((tmp & 0x7F) | 0x80);
} while ((tmp >>= 7) != 0);
blob[value - 1] = (byte)(blob[value - 1] & ~0x80);
writer.position += offset;
writer.ioIndex += offset;
}
break;
default:
throw new ArgumentOutOfRangeException("style");
}
// and this object is no longer a blockage - also flush if sensible
const int ADVISORY_FLUSH_SIZE = 1024;
if (--writer.flushLock == 0 && writer.ioIndex >= ADVISORY_FLUSH_SIZE)
{
ProtoWriter.Flush(writer);
}
}
private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw CreateException(writer);
}
int num = token.value;
if (writer.depth <= 0)
{
throw CreateException(writer);
}
if (writer.depth-- > 25)
{
writer.PopRecursionStack();
}
writer.packedFieldNumber = 0;
if (num < 0)
{
WriteHeaderCore(-num, WireType.EndGroup, writer);
writer.wireType = WireType.None;
}
else
{
switch (style)
{
case PrefixStyle.Fixed32:
{
int num2 = writer.ioIndex - num - 4;
WriteInt32ToBuffer(num2, writer.ioBuffer, num);
break;
}
case PrefixStyle.Fixed32BigEndian:
{
int num2 = writer.ioIndex - num - 4;
byte[] array2 = writer.ioBuffer;
WriteInt32ToBuffer(num2, array2, num);
byte b = array2[num];
array2[num] = array2[num + 3];
array2[num + 3] = b;
b = array2[num + 1];
array2[num + 1] = array2[num + 2];
array2[num + 2] = b;
break;
}
case PrefixStyle.Base128:
{
int num2 = writer.ioIndex - num - 1;
int num3 = 0;
uint num4 = (uint)num2;
while ((num4 >>= 7) != 0)
{
num3++;
}
if (num3 == 0)
{
writer.ioBuffer[num] = (byte)(num2 & 0x7F);
}
else
{
DemandSpace(num3, writer);
byte[] array = writer.ioBuffer;
Helpers.BlockCopy(array, num + 1, array, num + 1 + num3, num2);
num4 = (uint)num2;
do
{
array[num++] = (byte)((num4 & 0x7F) | 0x80);
}while ((num4 >>= 7) != 0);
array[num - 1] = (byte)(array[num - 1] & -129);
writer.position += num3;
writer.ioIndex += num3;
}
break;
}
default:
throw new ArgumentOutOfRangeException("style");
}
if (--writer.flushLock == 0 && writer.ioIndex >= 1024)
{
Flush(writer);
}
}
}
private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw ProtoWriter.CreateException(writer);
}
int value = token.value;
if (writer.depth <= 0)
{
throw ProtoWriter.CreateException(writer);
}
if (writer.depth-- > 25)
{
writer.PopRecursionStack();
}
writer.packedFieldNumber = 0;
if (value < 0)
{
ProtoWriter.WriteHeaderCore(-value, WireType.EndGroup, writer);
writer.wireType = WireType.None;
return;
}
switch (style)
{
case PrefixStyle.Base128:
{
int num = writer.ioIndex - value - 1;
int num2 = 0;
uint num3 = (uint)num;
while ((num3 >>= 7) != 0u)
{
num2++;
}
if (num2 == 0)
{
writer.ioBuffer[value] = (byte)(num & 127);
}
else
{
ProtoWriter.DemandSpace(num2, writer);
byte[] array = writer.ioBuffer;
Helpers.BlockCopy(array, value + 1, array, value + 1 + num2, num);
num3 = (uint)num;
do
{
array[value++] = (byte)((num3 & 127u) | 128u);
}while ((num3 >>= 7) != 0u);
array[value - 1] = (byte)((int)array[value - 1] & -129);
writer.position += num2;
writer.ioIndex += num2;
}
break;
}
case PrefixStyle.Fixed32:
{
int num = writer.ioIndex - value - 4;
ProtoWriter.WriteInt32ToBuffer(num, writer.ioBuffer, value);
break;
}
case PrefixStyle.Fixed32BigEndian:
{
int num = writer.ioIndex - value - 4;
byte[] array2 = writer.ioBuffer;
ProtoWriter.WriteInt32ToBuffer(num, array2, value);
byte b = array2[value];
array2[value] = array2[value + 3];
array2[value + 3] = b;
b = array2[value + 1];
array2[value + 1] = array2[value + 2];
array2[value + 2] = b;
break;
}
default:
throw new ArgumentOutOfRangeException("style");
}
if (--writer.flushLock == 0 && writer.ioIndex >= 1024)
{
ProtoWriter.Flush(writer);
}
}
private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
{
int num;
UInt32 num1;
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != ProtoBuf.WireType.None)
{
throw ProtoWriter.CreateException(writer);
}
int num2 = token.@value;
if (writer.depth <= 0)
{
throw ProtoWriter.CreateException(writer);
}
ProtoWriter protoWriter = writer;
int num3 = protoWriter.depth;
int num4 = num3;
protoWriter.depth = num3 - 1;
if (num4 > 25)
{
writer.PopRecursionStack();
}
writer.packedFieldNumber = 0;
if (num2 < 0)
{
ProtoWriter.WriteHeaderCore(-num2, ProtoBuf.WireType.EndGroup, writer);
writer.wireType = ProtoBuf.WireType.None;
return;
}
switch (style)
{
case PrefixStyle.Base128:
{
num = writer.ioIndex - num2 - 1;
int num5 = 0;
uint num6 = (uint)num;
while (true)
{
UInt32 num7 = num6 >> 7;
num6 = num7;
if (num7 == 0)
{
break;
}
num5++;
}
if (num5 != 0)
{
ProtoWriter.DemandSpace(num5, writer);
byte[] numArray = writer.ioBuffer;
Helpers.BlockCopy(numArray, num2 + 1, numArray, num2 + 1 + num5, num);
num6 = (uint)num;
do
{
int num8 = num2;
num2 = num8 + 1;
numArray[num8] = (byte)(num6 & 127 | 128);
num1 = num6 >> 7;
num6 = num1;
}while (num1 != 0);
numArray[num2 - 1] = (byte)(numArray[num2 - 1] & -129);
writer.position += num5;
writer.ioIndex += num5;
break;
}
else
{
writer.ioBuffer[num2] = (byte)(num & 127);
break;
}
}
case PrefixStyle.Fixed32:
{
num = writer.ioIndex - num2 - 4;
ProtoWriter.WriteInt32ToBuffer(num, writer.ioBuffer, num2);
break;
}
case PrefixStyle.Fixed32BigEndian:
{
num = writer.ioIndex - num2 - 4;
byte[] numArray1 = writer.ioBuffer;
ProtoWriter.WriteInt32ToBuffer(num, numArray1, num2);
byte num9 = numArray1[num2];
numArray1[num2] = numArray1[num2 + 3];
numArray1[num2 + 3] = num9;
num9 = numArray1[num2 + 1];
numArray1[num2 + 1] = numArray1[num2 + 2];
numArray1[num2 + 2] = num9;
break;
}
default:
{
throw new ArgumentOutOfRangeException("style");
}
}
ProtoWriter protoWriter1 = writer;
int num10 = protoWriter1.flushLock - 1;
int num11 = num10;
protoWriter1.flushLock = num10;
if (num11 == 0 && writer.ioIndex >= 1024)
{
ProtoWriter.Flush(writer);
}
}
public static void WriteBytes(byte[] data, int offset, int length, ProtoWriter writer)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
switch (writer.wireType)
{
case ProtoBuf.WireType.Fixed64:
{
if (length == 8)
{
break;
}
throw new ArgumentException("length");
}
case ProtoBuf.WireType.String:
{
ProtoWriter.WriteUInt32Variant((uint)length, writer);
writer.wireType = ProtoBuf.WireType.None;
if (length == 0)
{
return;
}
if (writer.flushLock != 0 || length <= (int)writer.ioBuffer.Length)
{
break;
}
ProtoWriter.Flush(writer);
writer.dest.Write(data, offset, length);
writer.position += length;
return;
}
case ProtoBuf.WireType.StartGroup:
case ProtoBuf.WireType.EndGroup:
{
throw ProtoWriter.CreateException(writer);
}
case ProtoBuf.WireType.Fixed32:
{
if (length == 4)
{
break;
}
throw new ArgumentException("length");
}
default:
{
throw ProtoWriter.CreateException(writer);
}
}
ProtoWriter.DemandSpace(length, writer);
Helpers.BlockCopy(data, offset, writer.ioBuffer, writer.ioIndex, length);
ProtoWriter.IncrementedAndReset(length, writer);
}