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; } }