/// <summary> /// Writes out part of an array of bytes. /// </summary> public void WriteRawBytes(byte[] value, int offset, int length) { if (limit - position >= length) { ByteArray.Copy(value, offset, buffer, position, length); // We have room in the current buffer. position += length; } else { // Write extends past current buffer. Fill the rest of this buffer and // flush. int bytesWritten = limit - position; ByteArray.Copy(value, offset, buffer, position, bytesWritten); offset += bytesWritten; length -= bytesWritten; position = limit; RefreshBuffer(); // Now deal with the rest. // Since we have an output stream, this is our buffer // and buffer offset == 0 if (length <= limit) { // Fits in new buffer. ByteArray.Copy(value, offset, buffer, 0, length); position = length; } else { // Write is very big. Let's do it all at once. output.Write(value, offset, length); } } }
/// <summary> /// Copies the entire byte array to the destination array provided at the offset specified. /// </summary> public void CopyTo(byte[] array, int position) { ByteArray.Copy(bytes, 0, array, position, bytes.Length); }
/// <summary> /// Constructs a ByteString from a portion of a byte array. /// </summary> public static ByteString CopyFrom(byte[] bytes, int offset, int count) { byte[] portion = new byte[count]; ByteArray.Copy(bytes, offset, portion, 0, count); return(new ByteString(portion)); }
public byte[] ReadRawBytes(int size) { if (size < 0) { throw InvalidProtocolBufferException.NegativeSize(); } if (this.totalBytesRetired + this.bufferPos + size > this.currentLimit) { this.SkipRawBytes(this.currentLimit - this.totalBytesRetired - this.bufferPos); throw InvalidProtocolBufferException.TruncatedMessage(); } if (size <= this.bufferSize - this.bufferPos) { byte[] array = new byte[size]; ByteArray.Copy(this.buffer, this.bufferPos, array, 0, size); this.bufferPos += size; return(array); } if (size < 4096) { byte[] array2 = new byte[size]; int num = this.bufferSize - this.bufferPos; ByteArray.Copy(this.buffer, this.bufferPos, array2, 0, num); this.bufferPos = this.bufferSize; this.RefillBuffer(true); while (size - num > this.bufferSize) { Buffer.BlockCopy(this.buffer, 0, array2, num, this.bufferSize); num += this.bufferSize; this.bufferPos = this.bufferSize; this.RefillBuffer(true); } ByteArray.Copy(this.buffer, 0, array2, num, size - num); this.bufferPos = size - num; return(array2); } int num2 = this.bufferPos; int num3 = this.bufferSize; this.totalBytesRetired += this.bufferSize; this.bufferPos = 0; this.bufferSize = 0; int i = size - (num3 - num2); List <byte[]> list = new List <byte[]>(); while (i > 0) { byte[] array3 = new byte[Math.Min(i, 4096)]; int num4; for (int j = 0; j < array3.Length; j += num4) { num4 = ((this.input == null) ? -1 : this.input.Read(array3, j, array3.Length - j)); if (num4 <= 0) { throw InvalidProtocolBufferException.TruncatedMessage(); } this.totalBytesRetired += num4; } i -= array3.Length; list.Add(array3); } byte[] array4 = new byte[size]; int num5 = num3 - num2; ByteArray.Copy(this.buffer, num2, array4, 0, num5); using (List <byte[]> .Enumerator enumerator = list.GetEnumerator()) { while (enumerator.MoveNext()) { byte[] current = enumerator.Current; Buffer.BlockCopy(current, 0, array4, num5, current.Length); num5 += current.Length; } } return(array4); }
public static ByteString CopyFrom(byte[] bytes, int offset, int count) { byte[] dst = new byte[count]; ByteArray.Copy(bytes, offset, dst, 0, count); return(new ByteString(dst)); }