public override int Read(byte[] buffer, int offset, int count)
{
this.EnsureNotClosed();
ThrowHelper.ArgumentNull((buffer == null), nameof(buffer));
ThrowHelper.ArgumentIndexOutOfRange((offset < 0), nameof(offset));
ThrowHelper.ArgumentLengthOutOfRange((count < 0), nameof(count));
ThrowHelper.ArgumentIndexLengthOutOfArray((offset + count > buffer.Length));
int n = Math.Min(this.Remaining, count);
if (n <= 0)
{
return(0);
}
Debug.Assert(_index + n >= 0, "_position + n >= 0"); // len is less than 2^31 -1.
if (n <= 8)
{
int byteCount = n;
while (--byteCount >= 0)
{
buffer[offset + byteCount] = this._buffer[this._index + byteCount];
}
}
else
{
System.Buffer.BlockCopy(_buffer, _index, buffer, offset, n);
}
_index += n;
return(n);
}
public static string ToString(byte[] bytes, int index, int length, bool wrap)
{
ThrowHelper.ArgumentNull((bytes == null), nameof(bytes));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + length) > bytes.Length));
string[] buffer = new string[length];
for (int i = index; i < index + length; i++)
{
buffer[i - index] = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
"{0:X2}",
bytes[i]);
}
if (wrap)
{
string[][] temp = Meision.Collections.CollectionManager.Divide <string>(buffer, 16);
StringBuilder builder = new StringBuilder();
for (int i = 0; i < temp.Length; i++)
{
builder.AppendLine(string.Join(" ", temp[i]));
}
return(builder.ToString());
}
else
{
return(string.Join(" ", buffer));
}
}
public override Boolean GetBoolean(byte[] data, int index)
{
ThrowHelper.ArgumentNull((data == null), nameof(data));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(Boolean)) > data.Length), nameof(index));
return(data[index] != 0);
}
/// <summary>
/// Set bit mask for original
/// </summary>
/// <param name="value">data value</param>
/// <param name="index">Index from right</param>
/// <returns>True is bit is 1, else false.</returns>
public static bool GetBit(UInt64 value, int index)
{
ThrowHelper.ArgumentIndexOutOfRange(((index < 0) || (index >= sizeof(UInt64) * UnitTable.ByteToBit)), nameof(index));
UInt64 mask = (UInt64)((UInt64)1 << index);
return((value & mask) != 0);
}
public static byte[] GetSegment(this byte[] array, int offset)
{
// Validate parameter(s).
ThrowHelper.ArgumentNull((array == null), nameof(array));
ThrowHelper.ArgumentIndexOutOfRange(((offset < 0) || (offset > array.Length)), nameof(offset));
return(Bytes.GetSegment(array, offset, array.Length - offset));
}
public override SByte GetSByte(byte[] bytes, int index)
{
ThrowHelper.ArgumentNull((bytes == null), nameof(bytes));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(SByte)) > bytes.Length), nameof(index));
return((SByte)bytes[index]);
}
public override void ToBytes(SByte value, byte[] bytes, int index)
{
ThrowHelper.ArgumentNull((bytes == null), nameof(bytes));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(SByte)) > bytes.Length), nameof(index));
bytes[index] = (Byte)value;
}
public override Char GetChar(byte[] data, int index)
{
ThrowHelper.ArgumentNull((data == null), nameof(data));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(Char)) > data.Length), nameof(index));
return((Char)this.GetUInt16(data, index));
}
public override void ToBytes(Boolean value, byte[] bytes, int index)
{
ThrowHelper.ArgumentNull((bytes == null), nameof(bytes));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(Boolean)) > bytes.Length), nameof(index));
Endian.__little.ToBytes(value, bytes, index);
Meision.Collections.Bytes.Reverse(bytes, index, sizeof(Boolean));
}
/// <summary>
/// Find the index of pattern in origin array. BMH algorithm search
/// </summary>
/// <param name="origin">origin bytes.</param>
/// <param name="index">index.</param>
/// <param name="length">searching length</param>
/// <param name="pattern">Find bytes.</param>
/// <returns>Index position.</returns>
public static int Search(byte[] origin, int index, byte[] pattern)
{
// Validate parameter(s).
ThrowHelper.ArgumentNull((origin == null), nameof(origin));
ThrowHelper.ArgumentIndexOutOfRange(((index < 0) || (index > origin.Length)), nameof(index));
ThrowHelper.ArgumentNull((pattern == null), nameof(pattern));
return(Bytes.Search(origin, index, origin.Length - index, pattern));
}
public BufferStream(byte[] buffer, int offset, int count, bool writable, bool isLittleEndian)
{
ThrowHelper.ArgumentNull((buffer == null), nameof(buffer));
ThrowHelper.ArgumentIndexOutOfRange((offset < 0), nameof(offset));
ThrowHelper.ArgumentLengthOutOfRange((count < 0), nameof(count));
ThrowHelper.ArgumentIndexLengthOutOfArray((offset + count > buffer.Length));
this.InitFromExternBuffer(buffer, offset, count, writable, isLittleEndian);
}
public override unsafe Double GetDouble(byte[] data, int index)
{
ThrowHelper.ArgumentNull((data == null), nameof(data));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(Double)) > data.Length), nameof(index));
Int64 temp = this.GetInt64(data, index);
return(*(((float *)&temp)));
}
//public static void ToBytes<T>(T value, byte[] buffer, int index = 0) where T : struct
//{
// ToBytes((object)value, buffer, index);
//}
public static void ToBytes(object value, byte[] buffer, int index = 0)
{
ThrowHelper.ArgumentNull((buffer == null), nameof(buffer));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
int size = (!value.GetType().IsEnum) ? Marshal.SizeOf(value) : Marshal.SizeOf(Enum.GetUnderlyingType(value.GetType()));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + size) > buffer.Length));
ObjectConvert.ToBytes(value, size, buffer, index);
}
public static object FromBytes(Type type, byte[] buffer, int index = 0)
{
ThrowHelper.ArgumentNull((buffer == null), nameof(buffer));
int size = (!type.IsEnum) ? Marshal.SizeOf(type) : Marshal.SizeOf(Enum.GetUnderlyingType(type));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + size) > buffer.Length));
return(FromBytes(type, size, buffer, index));
}
public override unsafe void ToBytes(Double value, byte[] bytes, int index)
{
ThrowHelper.ArgumentNull((bytes == null), nameof(bytes));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(Double)) > bytes.Length), nameof(index));
fixed(byte *pointer = bytes)
{
*((Double *)(pointer + index)) = value;
}
}
public static T[] GetSegment <T>(this T[] array, long offset, long length)
{
ThrowHelper.ArgumentNull((array == null), nameof(array));
ThrowHelper.ArgumentIndexOutOfRange((offset < 0), nameof(offset));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray(((offset + length) > array.Length));
T[] buffer = new T[length];
Array.Copy(array, offset, buffer, 0, length);
return(buffer);
}
public override unsafe Double GetDouble(byte[] bytes, int index)
{
ThrowHelper.ArgumentNull((bytes == null), nameof(bytes));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(Double)) > bytes.Length), nameof(index));
fixed(byte *pointer = bytes)
{
return(*((Double *)(pointer + index)));
}
}
public void ReadBytes(byte[] buffer, int index, int count)
{
ThrowHelper.ArgumentNull((buffer == null), nameof(buffer));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentLengthOutOfRange((count < 0), nameof(count));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + count) > buffer.Length));
this.EnsureGetSpace(count);
System.Buffer.BlockCopy(this._buffer, this._index, buffer, index, count);
this._index += count;
}
public static byte[] GetSegment(this byte[] array, int offset, int length)
{
// Validate parameter(s).
ThrowHelper.ArgumentNull((array == null), nameof(array));
ThrowHelper.ArgumentIndexOutOfRange((offset < 0), nameof(offset));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray(((offset + length) > array.Length));
byte[] buffer = new byte[length];
System.Buffer.BlockCopy(array, offset, buffer, 0, length);
return(buffer);
}
public void WriteBytes(byte[] values, int index, int count)
{
ThrowHelper.ArgumentNull((values == null), nameof(values));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentLengthOutOfRange((count < 0), nameof(count));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + count) > values.Length));
this.EnsureWriteSpace(count);
System.Buffer.BlockCopy(values, index, this._buffer, this._index, count);
this._index += count;
}
/// <summary>
/// Find the index of pattern in origin array. BMH algorithm search
/// </summary>
/// <param name="origin">origin bytes.</param>
/// <param name="index">start index.</param>
/// <param name="length">searching length</param>
/// <param name="pattern">Find bytes.</param>
/// <returns>Index position.</returns>
public static int Search(byte[] origin, int index, int length, byte[] pattern)
{
// Validate parameter(s).
ThrowHelper.ArgumentNull((origin == null), nameof(origin));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + length) > origin.Length));
ThrowHelper.ArgumentNull((pattern == null), nameof(pattern));
if ((pattern.Length == 0) ||
(length < pattern.Length))
{
return(-1);
}
if (pattern.Length > 1)
{
#region Binary Search
unsafe
{
fixed(byte *pOrigin = origin)
fixed(byte *pPattern = pattern)
{
byte *result = BMHSearch(pOrigin + index, length, pPattern, pattern.Length);
if (result == null)
{
return(-1);
}
return((int)(result - pOrigin));
}
}
#endregion Binary Search
}
else
{
#region Normal Search
byte b = pattern[0];
for (int i = index; i < index + length; i++)
{
if (origin[i] == b)
{
return(i);
}
}
return(-1);
#endregion Normal Search
}
}
public static byte[] ToByteArray <T>(T[] array, int index, int length)
{
ThrowHelper.ArgumentNull((array == null), nameof(array));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + length) > array.Length));
byte[] buffer = new byte[length * Marshal.SizeOf(typeof(T))];
IntPtr point = Marshal.UnsafeAddrOfPinnedArrayElement(array, index);
Marshal.Copy(point, buffer, 0, buffer.Length);
return(buffer);
}
/// <summary>
/// Set bit mask for original
/// </summary>
/// <param name="value">data value</param>
/// <param name="index">Index from right</param>
/// <param name="flag">bit value</param>
/// <returns>New value</returns>
public static UInt64 SetBit(UInt64 value, int index, bool flag)
{
ThrowHelper.ArgumentIndexOutOfRange(((index < 0) || (index >= sizeof(UInt64) * UnitTable.ByteToBit)), nameof(index));
UInt64 mask = (UInt64)((UInt64)1 << index);
if (flag)
{
return((UInt64)(value | mask));
}
else
{
return((UInt64)(value & (~mask)));
}
}
/// <summary>
/// Set bit mask for original
/// </summary>
/// <param name="value">data value</param>
/// <param name="index">Index from right</param>
/// <param name="flag">bit value</param>
/// <returns>New value</returns>
public static Int32 SetBit(Int32 value, int index, bool flag)
{
ThrowHelper.ArgumentIndexOutOfRange(((index < 0) || (index >= sizeof(Int32) * UnitTable.ByteToBit)), nameof(index));
Int32 mask = (Int32)((Int32)1 << index);
if (flag)
{
return((Int32)(value | mask));
}
else
{
return((Int32)(value & (~mask)));
}
}
/// <summary>
/// Set bit mask for original
/// </summary>
/// <param name="value">data value</param>
/// <param name="index">Index from right</param>
/// <param name="flag">bit value</param>
/// <returns>New value</returns>
public static SByte SetBit(SByte value, int index, bool flag)
{
ThrowHelper.ArgumentIndexOutOfRange(((index < 0) || (index >= sizeof(SByte) * UnitTable.ByteToBit)), nameof(index));
SByte mask = (SByte)((SByte)1 << index);
if (flag)
{
return((SByte)(value | mask));
}
else
{
return((SByte)(value & (~mask)));
}
}
public override UInt64 GetUInt64(byte[] data, int index)
{
ThrowHelper.ArgumentNull((data == null), nameof(data));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexOutOfRange(((index + sizeof(UInt64)) > data.Length), nameof(index));
UInt64 temp = 0;
int end = index + sizeof(UInt64);
for (int i = index; i < end; i++)
{
temp <<= Meision.Algorithms.UnitTable.ByteToBit;
temp |= (UInt64)data[i];
}
return(temp);
}
public static bool Compare <T>(T[] source, int sourceIndex, T[] destination, int destinationIndex, int length)
{
ThrowHelper.ArgumentNull((source == null), nameof(source));
ThrowHelper.ArgumentIndexOutOfRange((sourceIndex < 0), nameof(sourceIndex));
ThrowHelper.ArgumentNull((destination == null), nameof(destination));
ThrowHelper.ArgumentIndexOutOfRange((destinationIndex < 0), nameof(destinationIndex));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray((((sourceIndex + length) > source.Length) || ((destinationIndex + length) > destination.Length)));
for (int i = 0; i < length; i++)
{
if (!source[sourceIndex + i].Equals(destination[destinationIndex + i]))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Receive data by size from server.
/// </summary>
/// <param name="instance">socket instance</param>
/// <param name="buffer">data array to receive</param>
/// <param name="offset">offset in data</param>
/// <param name="size">ensure receiving size</param>
public static void ReceiveBySize(this Socket instance, byte[] buffer, int offset, int size, SocketFlags socketFlags = SocketFlags.None)
{
ThrowHelper.ArgumentNull((buffer == null), nameof(buffer));
ThrowHelper.ArgumentIndexOutOfRange((offset < 0), nameof(offset));
ThrowHelper.ArgumentLengthOutOfRange((size < 0), nameof(size));
ThrowHelper.ArgumentIndexLengthOutOfArray(((offset + size) > buffer.Length));
int remaining = size;
while (remaining > 0)
{
int received = instance.Receive(buffer, offset + (size - remaining), remaining, socketFlags);
if (received == 0)
{
throw new InvalidOperationException(SR.Socket_Exception_ReceiveEmtpy);
}
remaining -= received;
}
}
public static unsafe int GetHashCode(byte[] array, int offset, int length)
{
ThrowHelper.ArgumentNull((array == null), nameof(array));
ThrowHelper.ArgumentIndexOutOfRange((offset < 0), nameof(offset));
ThrowHelper.ArgumentLengthOutOfRange((length < 0), nameof(length));
ThrowHelper.ArgumentIndexLengthOutOfArray(((offset + length) > array.Length));
fixed(byte *pArray = &array[offset])
{
int hash = 0;
int times = length / sizeof(int);
int mod = length % sizeof(int);
int *pointer = (int *)pArray;
// Run times
for (int i = 0; i < times; i++)
{
hash ^= *pointer;
pointer++;
}
// compute last bytes.
switch (mod)
{
case 1:
hash ^= (array[offset + length - 1]);
break;
case 2:
hash ^= ((array[offset + length - 2]) | (array[offset + length - 1] << 8));
break;
case 3:
hash ^= ((array[offset + length - 3]) | (array[offset + length - 2] << 8) | (array[offset + length - 1] << 16));
break;
default:
break;
}
return(hash);
}
}
public static void Reverse(byte[] data, int index, int count)
{
ThrowHelper.ArgumentNull((data == null), nameof(data));
ThrowHelper.ArgumentIndexOutOfRange((index < 0), nameof(index));
ThrowHelper.ArgumentIndexLengthOutOfArray(((index + count) > data.Length));
int middle = index + count / 2;
int upper = index + count - 1;
for (int i = index; i < middle; i++)
{
// Locate destination.
int j = upper - (i - index);
// Swap i, j
byte temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
