public override void GetBytes(int index, IChannelBuffer dst, int dstIndex, int length)
{
var data = new byte[length];
Buffer.GetBytes(index, data);
dst.SetBytes(dstIndex, data, 0, length);
}
public static bool Equals(IChannelBuffer bufferA, IChannelBuffer bufferB)
{
int aLen = bufferA.ReadableBytes;
if (aLen != bufferB.ReadableBytes)
{
return(false);
}
int byteCount = aLen & 7;
int aIndex = bufferA.ReaderIndex;
int bIndex = bufferB.ReaderIndex;
for (int i = byteCount; i > 0; i--)
{
if (bufferA.GetByte(aIndex) != bufferB.GetByte(bIndex))
{
return(false);
}
aIndex++;
bIndex++;
}
return(true);
}
public static int Compare(IChannelBuffer bufferA, IChannelBuffer bufferB)
{
int aLen = bufferA.ReadableBytes;
int bLen = bufferB.ReadableBytes;
int minLength = Math.Min(aLen, bLen);
int aIndex = bufferA.ReaderIndex;
int bIndex = bufferB.ReaderIndex;
for (int i = minLength; i > 0; i--)
{
byte va = bufferA.GetByte(aIndex);
byte vb = bufferB.GetByte(bIndex);
if (va > vb)
{
return(1);
}
else if (va < vb)
{
return(-1);
}
aIndex++;
bIndex++;
}
return(aLen - bLen);
}
public void SetBytes(int index, IChannelBuffer src, int length)
{
if (length > src.ReadableBytes)
{
throw new IndexOutOfRangeException();
}
SetBytes(index, src, src.ReaderIndex, length);
}
public void GetBytes(int index, IChannelBuffer dst, int length)
{
if (length > dst.WriteableBytes)
{
throw new IndexOutOfRangeException();
}
GetBytes(index, dst, dst.WriterIndex, length);
}
public void ReadBytes(IChannelBuffer dst, int length)
{
if (length > dst.WriteableBytes)
{
throw new IndexOutOfRangeException();
}
ReadBytes(dst, dst.WriterIndex, length);
dst.SetWriterIndex(dst.WriterIndex + length);
}
public void WriteBytes(IChannelBuffer src, int length)
{
if (length > src.ReadableBytes)
{
throw new IndexOutOfRangeException();
}
WriteBytes(src, src.ReaderIndex, length);
src.SetReaderIndex(src.ReaderIndex + length);
}
public override void SetBytes(int index, IChannelBuffer src, int srcIndex, int length)
{
if (src is HeapChannelBuffer buffer)
{
SetBytes(index, buffer.Array, srcIndex, length);
}
else
{
src.GetBytes(srcIndex, _array, index, length);
}
}
public IChannelBuffer ReadBytes(int length)
{
CheckReadableBytes(length);
if (length == 0)
{
return(ChannelBuffers.EmptyBuffer);
}
IChannelBuffer buf = Factory.GetBuffer(length);
buf.WriteBytes(this, _readerIndex, length);
_readerIndex += length;
return(buf);
}
public IChannelBuffer GetBuffer(IByteBuffer nioBuffer)
{
if (nioBuffer.HasArray)
{
return(ChannelBuffers.WrappedBuffer(nioBuffer));
}
IChannelBuffer buf = GetBuffer((IByteBuffer)nioBuffer.Duplicate());
int pos = nioBuffer.ReaderIndex;
buf.WriteBytes(nioBuffer);
nioBuffer.SetReaderIndex(pos);
return(buf);
}
public override void SetBytes(int index, IChannelBuffer src, int srcIndex, int length)
{
if (src is ByteBufferBackedChannelBuffer)
{
ByteBufferBackedChannelBuffer bbsrc = (ByteBufferBackedChannelBuffer)src;
IByteBuffer data = bbsrc.Buffer.Duplicate();
data.Slice(srcIndex, length);
SetBytes(index, data);
}
else if (Buffer.HasArray)
{
src.GetBytes(srcIndex, Buffer.Array, index + Buffer.ArrayOffset, length);
}
else
{
src.GetBytes(srcIndex, this, index, length);
}
}
public abstract void SetBytes(int index, IChannelBuffer src, int srcIndex, int length);
public int CompareTo(IChannelBuffer that)
{
return(ChannelBuffers.Compare(this, that));
}
public void GetBytes(int index, IChannelBuffer dst)
{
GetBytes(index, dst, dst.WriteableBytes);
}
public abstract void GetBytes(int index, IChannelBuffer dst, int dstIndex, int length);
public void WriteBytes(IChannelBuffer src, int srcIndex, int length)
{
SetBytes(_writerIndex, src, srcIndex, length);
_writerIndex += length;
}
public void WriteBytes(IChannelBuffer src)
{
WriteBytes(src, src.ReadableBytes);
}
public void ReadBytes(IChannelBuffer dst, int dstIndex, int length)
{
CheckReadableBytes(length);
GetBytes(_readerIndex, dst, dstIndex, length);
_readerIndex += length;
}
public void SetBytes(int index, IChannelBuffer src)
{
SetBytes(index, src, src.ReadableBytes);
}
public void ReadBytes(IChannelBuffer dst)
{
ReadBytes(dst, dst.WriteableBytes);
}
public override void GetBytes(int index, IChannelBuffer dst, int dstIndex, int length)
{
throw new NotImplementedException();
}
