private static byte[] GetBytes(Stream stream, int initialLength) { if (stream.Position > 0) { stream.Position = 0; } // If we've been passed an unhelpful initial length, just // use 32K. if (initialLength < 1) { initialLength = 32768; } byte[] buffer = SafeMemoryAllocator.CreateArray <byte>(initialLength); int read = 0; int chunk; while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0) { read += chunk; // If we've reached the end of our buffer, check to see if there's // any more information if (read == buffer.Length) { int nextByte = stream.ReadByte(); // End of stream? If so, we're done if (nextByte == -1) { return(buffer); } // Nope. Resize the buffer, put in the byte we've just // read, and continue byte[] newBuffer = new byte[buffer.Length * 2]; Buffer.BlockCopy(buffer, 0, newBuffer, 0, Buffer.ByteLength(buffer)); newBuffer[read] = (byte)nextByte; buffer = newBuffer; read++; } } // Buffer is now too big. Shrink it. byte[] ret = SafeMemoryAllocator.CreateArray <byte>(read); Buffer.BlockCopy(buffer, 0, ret, 0, Buffer.ByteLength(ret)); return(ret); }
/// <summary> /// Converts the int array to a byte array. /// </summary> /// <param name="integers">The int array to convert.</param> /// <returns>the byte array representation of the specified int array</returns> public static byte[] ConvertIntArrayToByteArray(int[] integers) { if (integers == null || integers.Length == 0) { return(new byte[0]); } int sizeInBytes = integers.Length * 4; byte[] bytes = SafeMemoryAllocator.CreateArray <byte>(sizeInBytes); Buffer.BlockCopy(integers, 0, bytes, 0, sizeInBytes); return(bytes); }
/// <summary> /// Converts the byte array to an int array. /// </summary> /// <param name="bytes">The byte array to convert.</param> /// <returns>the int array representation of the specified byte array</returns> /// <remarks>This method expects the specified byte array's length to be divisible by 4 (the number of bytes for a single int)</remarks> /// <exception cref="ArgumentOutOfRangeException">thrown if the specified byte array is not divisible by 4</exception> public static int[] ConvertByteArrayToIntArray(byte[] bytes) { if (bytes == null || bytes.Length == 0) { return(new int[0]); } if (bytes.Length % 4 != 0) { throw new ArgumentOutOfRangeException("bytes", "This method expects the specified byte array's length to be divisible by 4 (the number of bytes for a single int)"); } int sizeInIntegers = bytes.Length / 4; int[] integers = SafeMemoryAllocator.CreateArray <int>(sizeInIntegers); Buffer.BlockCopy(bytes, 0, integers, 0, bytes.Length); return(integers); }
private static byte[] ReadBytes(IPrimitiveReader reader, int count) { if (count < 0) { throw new InvalidDataException(); } var result = SafeMemoryAllocator.CreateArray <byte>(count); int remaining = count; while (remaining > 0) { int read = reader.BaseStream.Read(result, count - remaining, remaining); if (read <= 0) { throw new InvalidDataException("Unexpected end of stream"); } remaining -= read; } return(result); }
public static BitArray ReadBitArray(this IPrimitiveReader reader) { var count = reader.ReadVarInt32(); if (count == -1) { return(null); } if (count < 0) { reader.RaiseInvalidDataException(); } var buffer = SafeMemoryAllocator.CreateArray <byte>(RoundToNearest8(count)); reader.BaseStream.Read(buffer, 0, buffer.Length); var result = new BitArray(buffer) { Length = count }; return(result); }