public SlicedArrayBuffer(IArrayBuffer <T> buffer, int index, int length) : base(length) { if (index < 0 || index > buffer.Capacity - length) { throw new ArgumentOutOfRangeException(nameof(index), $"{buffer}.slice({index}, {length})"); } var slicedByteBuf = buffer as SlicedArrayBuffer <T>; if (slicedByteBuf != null) { this.buffer = slicedByteBuf.buffer; this.adjustment = slicedByteBuf.adjustment + index; } else if (buffer is DuplicatedArrayBuffer <T> ) { this.buffer = buffer.Unwrap(); this.adjustment = index; } else { this.buffer = buffer; this.adjustment = index; } this.sliceLength = length; this.SetWriterIndex(length); }
public override IArrayBuffer <T> Duplicate() { IArrayBuffer <T> duplicate = this.buffer.Slice(this.adjustment, this.sliceLength); duplicate.SetIndex(this.ReaderIndex, this.WriterIndex); return(duplicate); }
protected static IArrayBuffer <T> ToLeakAwareBuffer(IArrayBuffer <T> buf) { IResourceLeak leak; switch (ResourceLeakDetector.Level) { case ResourceLeakDetector.DetectionLevel.Simple: leak = AbstractArrayBuffer <T> .LeakDetector.Open(buf); if (leak != null) { buf = new SimpleLeakAwareArrayBuffer <T>(buf, leak); } break; case ResourceLeakDetector.DetectionLevel.Advanced: case ResourceLeakDetector.DetectionLevel.Paranoid: leak = AbstractArrayBuffer <T> .LeakDetector.Open(buf); if (leak != null) { buf = new AdvancedLeakAwareArrayBuffer <T>(buf, leak); } break; case ResourceLeakDetector.DetectionLevel.Disabled: break; default: throw new ArgumentOutOfRangeException($"Unknown type {ResourceLeakDetector.Level}"); } return(buf); }
public string ReadString(Encoding encoding) { Contract.Requires(encoding != null); IArrayBuffer <byte> buffer = this.ArrayBuffer; if (buffer == null) { throw new ObjectDisposedException( $"{nameof(ReadableBuffer)} has already been disposed."); } int length = buffer.ReadableCount; if (length == 0) { return(string.Empty); } string result = buffer.GetString(length, encoding); buffer.Skip(length); return(result); }
internal ByteBuffer Buffer() { IArrayBuffer <byte> buffer = this.ArrayAllocator.Buffer(); var byteBuffer = new ByteBuffer(buffer); return(byteBuffer); }
internal ByteBuffer Buffer(int initialCapacity, int maxCapacity) { IArrayBuffer <byte> buffer = this.ArrayAllocator.Buffer(initialCapacity, maxCapacity); var byteBuffer = new ByteBuffer(buffer); return(byteBuffer); }
IArrayBuffer <byte> ReleasedBuffer() { IArrayBuffer <byte> newBuffer = this.allocator.Buffer(8); Assert.True(newBuffer.Release()); return(newBuffer); }
public static void SetBoolean(this IArrayBuffer <byte> buffer, int start, bool value) { Contract.Requires(buffer != null); buffer.CheckIndex(start); buffer.Array[buffer.WriterIndex] = (byte)(value ? 1 : 0); }
public void TestSequentialHeapBufferTransfer1() { var valueContent = new byte[BlockSize * 2]; IArrayBuffer <byte> value = Unpooled.WrappedBuffer(valueContent); this.buffer.SetWriterIndex(0); for (int i = 0; i < this.buffer.Capacity - BlockSize + 1; i += BlockSize) { this.random.NextBytes(valueContent); Assert.Equal(0, this.buffer.ReaderIndex); Assert.Equal(i, this.buffer.WriterIndex); this.buffer.Write(value, this.random.Next(BlockSize), BlockSize); Assert.Equal(0, value.ReaderIndex); Assert.Equal(valueContent.Length, value.WriterIndex); } this.random = new Random(this.seed); var expectedValueContent = new byte[BlockSize * 2]; IArrayBuffer <byte> expectedValue = Unpooled.WrappedBuffer(expectedValueContent); for (int i = 0; i < this.buffer.Capacity - BlockSize + 1; i += BlockSize) { this.random.NextBytes(expectedValueContent); int valueOffset = this.random.Next(BlockSize); Assert.Equal(i, this.buffer.ReaderIndex); Assert.Equal(Capacity, this.buffer.WriterIndex); this.buffer.Read(value, valueOffset, BlockSize); for (int j = valueOffset; j < valueOffset + BlockSize; j++) { Assert.Equal(expectedValue.Get(j), value.Get(j)); } Assert.Equal(0, value.ReaderIndex); Assert.Equal(valueContent.Length, value.WriterIndex); } }
public void Duplicate() { for (int i = 0; i < this.buffer.Capacity; i++) { byte value = (byte)this.random.Next(); this.buffer.Set(i, value); } int readerIndex = Capacity / 3; int writerIndex = Capacity * 2 / 3; this.buffer.SetIndex(readerIndex, writerIndex); // Make sure all properties are copied. IArrayBuffer <byte> duplicate = this.buffer.Duplicate(); Assert.Equal(this.buffer.ReaderIndex, duplicate.ReaderIndex); Assert.Equal(this.buffer.WriterIndex, duplicate.WriterIndex); Assert.Equal(this.buffer.Capacity, duplicate.Capacity); for (int i = 0; i < duplicate.Capacity; i++) { Assert.Equal(this.buffer.Get(i), duplicate.Get(i)); } // Make sure the this.buffer content is shared. this.buffer.Set(readerIndex, (byte)(this.buffer.Get(readerIndex) + 1)); Assert.Equal(this.buffer.Get(readerIndex), duplicate.Get(readerIndex)); duplicate.Set(1, (byte)(duplicate.Get(1) + 1)); Assert.Equal(this.buffer.Get(1), duplicate.Get(1)); }
public void RandomHeapBufferTransfer2() { var valueContent = new byte[BlockSize * 2]; IArrayBuffer <byte> value = Unpooled.WrappedBuffer(valueContent); for (int i = 0; i < this.buffer.Capacity - BlockSize + 1; i += BlockSize) { this.random.NextBytes(valueContent); this.buffer.Set(i, value, this.random.Next(BlockSize), BlockSize); } this.random = new Random(this.seed); var expectedValueContent = new byte[BlockSize * 2]; IArrayBuffer <byte> expectedValue = Unpooled.WrappedBuffer(expectedValueContent); for (int i = 0; i < this.buffer.Capacity - BlockSize + 1; i += BlockSize) { this.random.NextBytes(expectedValueContent); int valueOffset = this.random.Next(BlockSize); this.buffer.Get(i, value, valueOffset, BlockSize); for (int j = valueOffset; j < valueOffset + BlockSize; j++) { Assert.Equal(expectedValue.Get(j), value.Get(j)); } } }
public void RandomHeapBufferTransfer1() { var valueContent = new byte[BlockSize]; IArrayBuffer <byte> value = Unpooled.WrappedBuffer(valueContent); for (int i = 0; i < this.buffer.Capacity - BlockSize + 1; i += BlockSize) { this.random.NextBytes(valueContent); value.SetIndex(0, BlockSize); this.buffer.Set(i, value); Assert.Equal(BlockSize, value.ReaderIndex); Assert.Equal(BlockSize, value.WriterIndex); } this.random = new Random(this.seed); var expectedValueContent = new byte[BlockSize]; IArrayBuffer <byte> expectedValue = Unpooled.WrappedBuffer(expectedValueContent); for (int i = 0; i < this.buffer.Capacity - BlockSize + 1; i += BlockSize) { this.random.NextBytes(expectedValueContent); value.Clear(); this.buffer.Get(i, value); Assert.Equal(0, value.ReaderIndex); Assert.Equal(BlockSize, value.WriterIndex); for (int j = 0; j < BlockSize; j++) { Assert.Equal(expectedValue.Get(j), value.Get(j)); } } }
internal WritableBuffer(IArrayBuffer <byte> buffer, bool isLittleEndian) { Contract.Requires(buffer != null); this.ArrayBuffer = buffer; this.isLittleEndian = isLittleEndian; }
static void OnReadCallback(IntPtr handle, IntPtr nread, ref uv_buf_t buf) { var stream = HandleContext.GetTarget <StreamHandle>(handle); IArrayBuffer <byte> byteBuffer = stream.pipeline.GetBuffer(ref buf); stream.OnReadCallback(byteBuffer, (int)nread.ToInt64()); }
public static bool Equals(IArrayBuffer <byte> bufferA, IArrayBuffer <byte> bufferB) { int aLen = bufferA.ReadableCount; return(aLen == bufferB.ReadableCount && Equals(bufferA, bufferA.ReaderIndex, bufferB, bufferB.ReaderIndex, aLen)); }
public static void SetInt64(this IArrayBuffer <byte> buffer, int start, long value, bool isLittleEndian) { Contract.Requires(buffer != null); buffer.CheckIndex(start, sizeof(long)); int index = buffer.ArrayOffset + start; if (isLittleEndian) { buffer.Array[index] = (byte)value; buffer.Array[index + 1] = (byte)(value >> 8); buffer.Array[index + 2] = (byte)(value >> 16); buffer.Array[index + 3] = (byte)(value >> 24); buffer.Array[index + 4] = (byte)(value >> 32); buffer.Array[index + 5] = (byte)(value >> 40); buffer.Array[index + 6] = (byte)(value >> 48); buffer.Array[index + 7] = (byte)(value >> 56); } else { buffer.Array[index] = (byte)(value >> 56); buffer.Array[index + 1] = (byte)(value >> 48); buffer.Array[index + 2] = (byte)(value >> 40); buffer.Array[index + 3] = (byte)(value >> 32); buffer.Array[index + 4] = (byte)(value >> 24); buffer.Array[index + 5] = (byte)(value >> 16); buffer.Array[index + 6] = (byte)(value >> 8); buffer.Array[index + 7] = (byte)value; } }
public static long GetInt64(this IArrayBuffer <byte> buffer, int start, bool isLittleEndian) { Contract.Requires(buffer != null); buffer.CheckIndex(start, sizeof(long)); int index = buffer.ArrayOffset + start; if (isLittleEndian) { // ReSharper disable once RedundantCast return((long)buffer.Array[index] | (long)buffer.Array[index + 1] << 8 | (long)buffer.Array[index + 2] << 16 | (long)buffer.Array[index + 3] << 24 | (long)buffer.Array[index + 4] << 32 | (long)buffer.Array[index + 5] << 40 | (long)buffer.Array[index + 6] << 48 | (long)buffer.Array[index + 7] << 56); } return(((long)buffer.Array[index] & 0xFF) << 56 | ((long)buffer.Array[index + 1] & 0xFF) << 48 | ((long)buffer.Array[index + 2] & 0xFF) << 40 | ((long)buffer.Array[index + 3] & 0xFF) << 32 | ((long)buffer.Array[index + 4] & 0xFF) << 24 | ((long)buffer.Array[index + 5] & 0xFF) << 16 | ((long)buffer.Array[index + 6] & 0xFF) << 8 | ((long)buffer.Array[index + 7] & 0xFF)); }
public static IArrayBuffer <byte> CopiedBuffer(params IArrayBuffer <byte>[] buffers) { Contract.Requires(buffers != null); if (buffers.Length == 0) { return(Empty); } if (buffers.Length == 1) { return(CopiedBuffer(buffers[0])); } long newlength = 0; foreach (IArrayBuffer <byte> buffer in buffers) { newlength += buffer.ReadableCount; } var mergedArray = new byte[newlength]; for (int i = 0, j = 0; i < buffers.Length; i++) { IArrayBuffer <byte> b = buffers[i]; int bLen = b.ReadableCount; b.Get(b.ReaderIndex, mergedArray, j, bLen); j += bLen; } return(WrappedBuffer(mergedArray)); }
void OnReceivedCallback(IArrayBuffer <byte> byteBuffer, int status, IPEndPoint remoteEndPoint) { // status (nread) // Number of bytes that have been received. // 0 if there is no more data to read. You may discard or repurpose the read buffer. // Note that 0 may also mean that an empty datagram was received (in this case addr is not NULL). // < 0 if a transmission error was detected. // For status = 0 (Nothing to read) if (status >= 0) { Contract.Assert(byteBuffer != null); if (Log.IsDebugEnabled) { // ReSharper disable once PossibleNullReferenceException Log.DebugFormat("{0} {1} read, buffer length = {2} status = {3}.", this.HandleType, this.InternalHandle, byteBuffer.Capacity, status); } this.InvokeRead(byteBuffer, status, remoteEndPoint); return; } Exception exception = NativeMethods.CreateError((uv_err_code)status); Log.Error($"{this.HandleType} {this.InternalHandle} read error, status = {status}", exception); this.bufferQueue.Clear(); this.InvokeRead(byteBuffer, 0, remoteEndPoint, exception); }
void InvokeRead(IArrayBuffer <byte> byteBuffer, int size, IPEndPoint remoteEndPoint, Exception error = null) { if (size == 0 && error == null) { // Filter out empty data received if not an error // // On windows the udp receive actually been call with empty data // for broadcast, on Linux, the receive is not called at all. // byteBuffer?.Release(); return; } ReadableBuffer buffer = size > 0 ? new ReadableBuffer(byteBuffer, size) : ReadableBuffer.Empty; var completion = new DatagramReadCompletion(ref buffer, error, remoteEndPoint); try { this.readAction?.Invoke(this, completion); } catch (Exception exception) { Log.Warn($"{nameof(Udp)} Exception whilst invoking read callback.", exception); } finally { completion.Dispose(); } }
public IArrayBuffer <T> ReadSlice(int length) { IArrayBuffer <T> slice = this.Slice(this.ReaderIndex, length); this.ReaderIndex += length; return(slice); }
internal uv_buf_t[] GetBuffer() { if (this.buffer == null) { throw new ObjectDisposedException( $"{nameof(BufferRef)} has already been disposed."); } if (this.handle.IsAllocated || this.array.IsAllocated) { throw new InvalidOperationException( $"{nameof(BufferRef)} has already been initialized and not released yet."); } IArrayBuffer <byte> arrayBufer = this.buffer; this.array = GCHandle.Alloc(arrayBufer.Array, GCHandleType.Pinned); IntPtr arrayHandle = this.array.AddrOfPinnedObject(); var bufs = new[] { new uv_buf_t(arrayHandle + this.index, this.length) }; this.handle = GCHandle.Alloc(bufs, GCHandleType.Pinned); return(bufs); }
void InvokeRead(IArrayBuffer <byte> byteBuffer, int size, Exception error = null, bool completed = false) { if (size == 0) { byteBuffer?.Release(); } ReadableBuffer buffer = byteBuffer != null && size > 0 ? new ReadableBuffer(byteBuffer, size) : ReadableBuffer.Empty; var completion = new StreamReadCompletion(ref buffer, error, completed); try { this.streamConsumer?.Consume(this.streamHandle, completion); } catch (Exception exception) { Log.Warn($"{nameof(Pipeline)} Exception whilst invoking read callback.", exception); } finally { completion.Dispose(); } }
public IArrayBuffer <T> Read(IArrayBuffer <T> destination, int dstIndex, int length) { this.CheckReadableCount(length); this.Get(this.ReaderIndex, destination, dstIndex, length); this.ReaderIndex += length; return(this); }
static int IndexOf(IArrayBuffer <byte> haystack, byte[] separator) { for (int i = haystack.ReaderIndex; i < haystack.WriterIndex; i++) { int haystackIndex = i; int needleIndex; for (needleIndex = 0; needleIndex < separator.Length; needleIndex++) { if (haystack.Get(haystackIndex) != separator[needleIndex]) { break; } else { haystackIndex++; if (haystackIndex == haystack.WriterIndex && needleIndex != separator.Length - 1) { return(-1); } } } if (needleIndex == separator.Length) { // Found the needle from the haystack! return(i - haystack.ReaderIndex); } } return(-1); }
public static string GetString(this IArrayBuffer <byte> buffer, int start, byte[] separator, Encoding encoding, out int count) { Contract.Requires(buffer != null); Contract.Requires(encoding != null); Contract.Requires(separator != null && separator.Length > 0); buffer.CheckIndex(start); int index = buffer.ArrayOffset + start; if (buffer.ReadableCount < separator.Length) { count = buffer.ReadableCount; return(encoding.GetString(buffer.Array, index, count)); } int frameLength = IndexOf(buffer, separator); if (frameLength == 0) // Leading separator { frameLength = separator.Length; } else if (frameLength < 0) // Not found { frameLength = buffer.ReadableCount; } count = frameLength; return(encoding.GetString(buffer.Array, index, count)); }
public WritableBuffer Allocate(int size) { Contract.Requires(size > 0); IArrayBuffer <byte> buffer = this.allocator.Buffer(size); return(new WritableBuffer(buffer)); }
public DuplicatedArrayBuffer(IArrayBuffer <T> source) : base(source.MaxCapacity) { var asDuplicate = source as DuplicatedArrayBuffer <T>; this.buffer = asDuplicate != null ? asDuplicate.buffer : source; this.SetIndex(source.ReaderIndex, source.WriterIndex); }
internal void OnReadCompleted(IArrayBuffer <byte> byteBuffer, int size) { Contract.Requires(byteBuffer != null); Contract.Requires(size >= 0); this.receiveBufferSizeEstimate.Record(size); this.InvokeRead(byteBuffer, size); }
public static void SetDouble(this IArrayBuffer <byte> buffer, int start, double value, bool isLittleEndian) { Contract.Requires(buffer != null); buffer.SetInt64(start, BitConverter.DoubleToInt64Bits(value), BitConverter.IsLittleEndian == isLittleEndian); }