/// <summary> /// 范围排序 /// </summary> /// <typeparam name="valueType">排序数据类型</typeparam> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序范围数据数量</param> /// <param name="comparer">排序比较器</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数据</returns> public static subArray <valueType> RangeSort <valueType> (valueType[] values, int startIndex, int count, Func <valueType, valueType, int> comparer, int skipCount, int getCount) { array.range range = new array.range(values.length(), startIndex, count); if ((count = range.GetCount) != 0) { array.range getRange = new array.range(count, skipCount, getCount); if ((getCount = getRange.GetCount) != 0) { if (comparer == null) { log.Error.Throw(log.exceptionType.Null); } skipCount = range.SkipCount + getRange.SkipCount; new rangeSorter <valueType> { Array = values, Comparer = comparer, SkipCount = skipCount, GetEndIndex = skipCount + getCount - 1 }.Sort(range.SkipCount, range.SkipCount + --count); return(subArray <valueType> .Unsafe(values, skipCount, getCount)); } } return(default(subArray <valueType>)); }
/// <summary> /// 压缩数据 /// </summary> /// <param name="oldData">原始数据</param> /// <param name="type">压缩类型</param> /// <param name="startIndex">起始位置</param> /// <param name="count">压缩字节数</param> /// <returns>压缩后的数据,失败返回null</returns> public static byte[] getCompress(this byte[] oldData, compression type, int startIndex, int count) { array.range range = new array.range(oldData.length(), startIndex, count); if (count == range.GetCount) { using (MemoryStream dataStream = new MemoryStream()) { using (Stream compressStream = dataStream.toCompressStream(CompressionMode.Compress, true, type)) { compressStream.Write(oldData, startIndex, count); } if (dataStream.Position < oldData.Length) { if (dataStream.Length != dataStream.Position) { dataStream.SetLength(dataStream.Position); } return(dataStream.ToArray()); } } return(null); } else if (count == 0) { return(null); } log.Default.Throw(log.exceptionType.IndexOutOfRange); return(null); }
/// <summary> /// 分割字符串 /// </summary> /// <param name="value">原字符串</param> /// <param name="startIndex">起始位置</param> /// <param name="length">分割字符串长度</param> /// <param name="split">分割符</param> /// <returns>字符子串集合</returns> public unsafe static subArray <subString> split(this string value, int startIndex, int length, char split) { array.range range = new array.range(value.length(), startIndex, length); if (range.GetCount != length) { fastCSharp.log.Error.Throw(log.exceptionType.IndexOutOfRange); } subArray <subString> values = default(subArray <subString>); if (value != null) { fixed(char *valueFixed = value) { char *last = valueFixed + range.SkipCount, end = last + range.GetCount; for (char *start = last; start != end;) { if (*start == split) { values.Add(subString.Unsafe(value, (int)(last - valueFixed), (int)(start - last))); last = ++start; } else { ++start; } } values.Add(subString.Unsafe(value, (int)(last - valueFixed), (int)(end - last))); } } return(values); }
/// <summary> /// 数组范围排序 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序范围数据数量</param> /// <param name="getKey">排序键值获取器</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数组</returns> public unsafe static valueType[] GetRangeSort/*Compare[0]*//*Compare[0]*/ <valueType> (valueType[] values, int startIndex, int count, Func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int skipCount, int getCount) { array.range range = new array.range(values.length(), startIndex, count); if ((count = range.GetCount) != 0) { array.range getRange = new array.range(count, skipCount, getCount); if ((getCount = getRange.GetCount) != 0) { if (getKey == null) { log.Error.Throw(log.exceptionType.Null); } unmanagedPool pool = fastCSharp.unmanagedPool.GetDefaultPool(count * sizeof(/*Type[2]*/ ulongSortIndex /*Type[2]*/)); pointer.size data = pool.Get(count * sizeof(/*Type[2]*/ ulongSortIndex /*Type[2]*/)); try { return(getRangeSort/*Compare[0]*//*Compare[0]*/ (values, range.SkipCount, count, getKey, getRange.SkipCount, getCount, (/*Type[2]*/ ulongSortIndex /*Type[2]*/ *)data.Data)); } finally { pool.Push(ref data); } } } return(nullValue <valueType> .Array); }
/// <summary> /// 范围排序 /// </summary> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序范围数据数量</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数据</returns> public unsafe static collection </*Type[0]*/ ulong /*Type[0]*/> RangeSort/*Compare[0]*//*Compare[0]*/ (/*Type[0]*/ ulong /*Type[0]*/[] values, int startIndex, int count, int skipCount, int getCount) { array.range range = new array.range(values.length(), startIndex, count); if ((count = range.GetCount) != 0) { array.range getRange = new array.range(count, skipCount, getCount); if ((getCount = getRange.GetCount) != 0) { skipCount = range.SkipCount + getRange.SkipCount; fixed(/*Type[0]*/ ulong /*Type[0]*/ *valueFixed = values) { /*Type[0]*/ ulong /*Type[0]*/ *skip = valueFixed + skipCount, start = valueFixed + range.SkipCount; new /*Type[1]*/ ulongRangeSorter/*Type[1]*//*Compare[0]*//*Compare[0]*/ { SkipCount = skip, GetEndIndex = skip + getCount - 1 }.Sort(start, start + --count); } return(new collection </*Type[0]*/ ulong /*Type[0]*/>(values, skipCount, getCount, true)); } } return(null); }
/// <summary> /// 范围排序 /// </summary> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序范围数据数量</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的新数据</returns> public unsafe static collection </*Type[0]*/ ulong /*Type[0]*/> GetRangeSort/*Compare[0]*//*Compare[0]*/ (/*Type[0]*/ ulong /*Type[0]*/[] values, int startIndex, int count, int skipCount, int getCount) { array.range range = new array.range(values.length(), startIndex, count); if ((count = range.GetCount) != 0) { array.range getRange = new array.range(count, skipCount, getCount); if ((getCount = getRange.GetCount) != 0) { /*Type[0]*/ ulong /*Type[0]*/[] newValues = new /*Type[0]*/ ulong /*Type[0]*/[count]; Buffer.BlockCopy(values, range.SkipCount * sizeof(/*Type[0]*/ ulong /*Type[0]*/), newValues, 0, count * sizeof(/*Type[0]*/ ulong /*Type[0]*/)); fixed(/*Type[0]*/ ulong /*Type[0]*/ *newValueFixed = newValues, valueFixed = values) { new /*Type[1]*/ ulongRangeSorter/*Type[1]*//*Compare[0]*//*Compare[0]*/ { SkipCount = newValueFixed + getRange.SkipCount, GetEndIndex = newValueFixed + getRange.SkipCount + getCount - 1 }.Sort(newValueFixed, newValueFixed + count - 1); } return(new collection </*Type[0]*/ ulong /*Type[0]*/>(newValues, getRange.SkipCount, getCount, true)); } } return(null); }
/// <summary> /// 数组范围排序 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序范围数据数量</param> /// <param name="getKey">排序键值获取器</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数组</returns> public unsafe static valueType[] GetRangeSort/*Compare[0]*//*Compare[0]*/ <valueType> (valueType[] values, int startIndex, int count, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int skipCount, int getCount) { array.range range = new array.range(values.length(), startIndex, count); if ((count = range.GetCount) != 0) { array.range getRange = new array.range(count, skipCount, getCount); if ((getCount = getRange.GetCount) != 0) { if (getKey == null) { log.Default.Throw(log.exceptionType.Null); } if (values.Length > (config.pub.Default.StreamBufferLength >> 4)) { /*Type[2]*/ ulongSortIndex /*Type[2]*/[] indexs = new /*Type[2]*/ ulongSortIndex /*Type[2]*/[count]; fixed(/*Type[2]*/ ulongSortIndex /*Type[2]*/ *fixedIndex = indexs) { return(getRangeSort/*Compare[0]*//*Compare[0]*/ (values, range.SkipCount, count, getKey, getRange.SkipCount, getCount, fixedIndex)); } } else { /*Type[2]*/ ulongSortIndex /*Type[2]*/ *fixedIndex = stackalloc /*Type[2]*/ ulongSortIndex /*Type[2]*/[count]; return(getRangeSort/*Compare[0]*//*Compare[0]*/ (values, range.SkipCount, count, getKey, getRange.SkipCount, getCount, fixedIndex)); } } } return(nullValue <valueType> .Array); }
/// <summary> /// 解压缩数据 /// </summary> /// <param name="compressData">压缩数据</param> /// <param name="type">压缩类型</param> /// <param name="startIndex">起始位置</param> /// <param name="count">解压缩字节数</param> /// <returns>解压缩后的数据</returns> public static memoryStream getDeCompressStream(this byte[] compressData, compression type, int startIndex, int count) { array.range range = new array.range(compressData.length(), startIndex, count); if (count == range.GetCount) { using (Stream memoryStream = new MemoryStream(compressData, 0, compressData.Length)) using (Stream compressStream = memoryStream.toCompressStream(CompressionMode.Decompress, false, type)) { memoryStream dataStream = new memoryStream(compressData.Length); byte[] buffer = new byte[config.pub.Default.StreamBufferLength]; for (int readLength = compressStream.Read(buffer, 0, config.pub.Default.StreamBufferLength); readLength != 0; readLength = compressStream.Read(buffer, 0, config.pub.Default.StreamBufferLength)) { dataStream.Write(buffer, 0, readLength); } return(dataStream); } } else if (count == 0) { return(null); } log.Default.Throw(log.exceptionType.IndexOutOfRange); return(null); }
public void Add(valueType[] values, int index, int count) { array.range range = new array.range(values.length(), index, count); if ((count = range.GetCount) != 0) { add(values, range.SkipCount, count); } }
/// <summary> /// 发送数据 /// </summary> /// <param name="data">数据</param> /// <param name="startIndex">起始位置</param> /// <param name="length">发送长度</param> /// <returns>是否成功</returns> public bool Send(byte[] data, int startIndex, int length) { if (length != 0 && startIndex >= 0) { array.range range = new array.range(data.length(), startIndex, length); return(range.GetCount == length && send(data, range.SkipCount, length)); } return(false); }
/// <summary> /// 转换成子集合(不清除数组) /// </summary> /// <param name="index">起始位置</param> /// <param name="count">数量,小于0表示所有</param> /// <returns>子集合</returns> public subArray <valueType> GetSub(int index, int count) { array.range range = new array.range(length, index, count < 0 ? length - index : count); if (range.GetCount > 0) { return(subArray <valueType> .Unsafe(array, startIndex + range.SkipCount, range.GetCount)); } return(default(subArray <valueType>)); }
/// <summary> /// 单向动态数组排序 /// </summary> /// <param name="list">待排序单向动态数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序数据数量</param> /// <returns>排序后新的单向动态数组</returns> public static /*Type[0]*/ ulong /*Type[0]*/[] getSort/*Compare[0]*//*Compare[0]*/ (this list </*Type[0]*/ ulong /*Type[0]*/> list, int startIndex, int count) { array.range range = new array.range(list.count(), startIndex, count); if ((count = range.GetCount) != 0) { return(algorithm.quickSort.GetSort/*Compare[0]*//*Compare[0]*/ (list.Unsafer.Array, range.SkipCount, count)); } return(nullValue </*Type[0]*/ ulong /*Type[0]*/> .Array); }
/// <summary> /// 单向动态数组排序 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <param name="list">待排序单向动态数组</param> /// <param name="getKey">排序键</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序数据数量</param> /// <returns>排序后的新数组</returns> public static valueType[] sort/*Compare[0]*//*Compare[0]*/ <valueType> (this list <valueType> list, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int startIndex, int count) { array.range range = new array.range(list.count(), startIndex, count); if ((count = range.GetCount) != 0) { return(algorithm.quickSort.GetSort/*Compare[0]*//*Compare[0]*/ (list.Unsafer.Array, getKey, range.SkipCount, count)); } return(nullValue <valueType> .Array); }
/// <summary> /// 数组排序 /// </summary> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序数据数量</param> public unsafe static void Sort/*Compare[0]*//*Compare[0]*/ (/*Type[0]*/ ulong /*Type[0]*/[] values, int startIndex, int count) { array.range range = new array.range(values.length(), startIndex, count); if (range.GetCount > 1) { fixed(/*Type[0]*/ ulong /*Type[0]*/ *valueFixed = values) { sort/*Compare[0]*//*Compare[0]*/ (valueFixed + range.SkipCount, valueFixed + range.EndIndex - 1); } } }
/// <summary> /// 范围排序 /// </summary> /// <param name="list">待排序单向动态数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">结束位置</param> /// <param name="skipCount">跳过记录数</param> /// <param name="getCount">获取记录数</param> /// <returns>排序范围数组</returns> public static collection </*Type[0]*/ ulong /*Type[0]*/> getRangeSort/*Compare[0]*//*Compare[0]*/ (this list </*Type[0]*/ ulong /*Type[0]*/> list, int startIndex, int count, int skipCount, int getCount) { array.range range = new array.range(list.count(), startIndex, count); if ((count = range.GetCount) != 0) { return(algorithm.quickSort.GetRangeSort/*Compare[0]*//*Compare[0]*/ (list.Unsafer.Array, range.SkipCount, count, skipCount, getCount)); } return(null); }
/// <summary> /// 压缩数据 /// </summary> /// <param name="data">原始数据</param> /// <param name="startIndex">起始位置</param> /// <param name="count">压缩字节数</param> /// <param name="seek">起始位置</param> /// <returns>压缩后的数据,失败返回null</returns> public subArray<byte> GetCompress(byte[] data, int startIndex, int count, int seek = 0, memoryPool memoryPool = null) { if (seek >= 0) { if (count == 0) return subArray<byte>.Unsafe(nullValue<byte>.Array, 0, 0); array.range range = new array.range(data.length(), startIndex, count); if (count == range.GetCount) return GetCompressUnsafe(data, startIndex, count, seek, memoryPool); } log.Error.Throw(log.exceptionType.IndexOutOfRange); return default(subArray<byte>); }
/// <summary> /// 数组子串 /// </summary> /// <param name="value">数组</param> /// <param name="startIndex">起始位置</param> /// <param name="length">长度</param> public static subArray <valueType> Create(valueType[] value, int startIndex, int length) { if (value == null) { fastCSharp.log.Error.Throw(log.exceptionType.Null); } array.range range = new array.range(value.Length, startIndex, length); if (range.GetCount != length) { fastCSharp.log.Error.Throw(log.exceptionType.IndexOutOfRange); } return(range.GetCount == 0 ? new subArray <valueType>(nullValue <valueType> .Array, 0, 0) : new subArray <valueType>(value, range.SkipCount, range.GetCount)); }
/// <summary> /// 解压缩数据 /// </summary> /// <param name="compressData">压缩数据</param> /// <param name="startIndex">起始位置</param> /// <param name="count">解压缩字节数</param> /// <param name="memoryPool">数据缓冲区内存池</param> /// <returns>解压缩后的数据</returns> public subArray <byte> GetDeCompress(byte[] compressData, int startIndex, int count, memoryPool memoryPool = null) { if (count > 0) { array.range range = new array.range(compressData.length(), startIndex, count); if (count == range.GetCount) { return(GetDeCompressUnsafe(compressData, range.SkipCount, count, memoryPool)); } } log.Error.Throw(log.exceptionType.IndexOutOfRange); return(default(subArray <byte>)); }
/// <summary> /// 数组范围排序 /// </summary> /// <typeparam name="valueType">数据类型</typeparam> /// <param name="values">待排序数组</param> /// <param name="indexs">排序索引</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数组</returns> public unsafe static valueType[] GetRangeSort/*Compare[0]*//*Compare[0]*/ <valueType> (valueType[] values, /*Type[2]*/ ulongSortIndex /*Type[2]*/[] indexs, int skipCount, int getCount) { if (values.length() != indexs.length()) { log.Default.Throw(log.exceptionType.IndexOutOfRange); } array.range range = new array.range(values.length(), skipCount, getCount); if ((getCount = range.GetCount) != 0) { fixed(/*Type[2]*/ ulongSortIndex /*Type[2]*/ *fixedIndex = indexs) return(getRangeSort/*Compare[0]*//*Compare[0]*/ (values, skipCount, getCount, fixedIndex)); } return(nullValue <valueType> .Array); }
/// <summary> /// 写数据 /// </summary> /// <param name="data">数据</param> /// <param name="index">起始位置</param> /// <param name="count">写入字节数</param> public void Write(byte[] data, int index, int count) { array.range range = new array.range(data.length(), index, count); if (range.GetCount == count) { prepLength(count); Buffer.BlockCopy(data, range.SkipCount, array, Length, count); Length += count; } else if (count != 0) { log.Error.Throw(log.exceptionType.IndexOutOfRange); } }
/// <summary> /// 数组范围排序 /// </summary> /// <typeparam name="valueType">排序数据类型</typeparam> /// <param name="values">待排序数组</param> /// <param name="comparer">排序比较器</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序数据数量</param> public static void Sort <valueType>(valueType[] values, Func <valueType, valueType, int> comparer, int startIndex, int count) { array.range range = new array.range(values.length(), startIndex, count); if (range.GetCount > 1) { if (comparer == null) { log.Error.Throw(log.exceptionType.Null); } new sorter <valueType> { Array = values, Comparer = comparer }.Sort(range.SkipCount, range.EndIndex - 1); } }
public subArray <valueType> Sub(int index, int count) { array.range range = new array.range(length, index, count < 0 ? length - index : count); if (range.GetCount > 0) { startIndex += range.SkipCount; length = range.GetCount; } else { startIndex = length = 0; } return(this); }
/// <summary> /// 转换成字节数组 /// </summary> /// <param name="index">起始位置</param> /// <param name="count">字节数</param> /// <returns>字节数组</returns> public byte[] GetArray(int index, int count) { array.range range = new array.range(Length, index, count); if (count == range.GetCount) { byte[] data = new byte[count]; Buffer.BlockCopy(data, index, data, 0, count); return(data); } else if (count == 0) { return(null); } log.Default.Throw(log.exceptionType.IndexOutOfRange); return(null); }
/// <summary> /// 范围排序 /// </summary> /// <typeparam name="valueType">排序数据类型</typeparam> /// <param name="values">待排序数组</param> /// <param name="startIndex">起始位置</param> /// <param name="count">排序范围数据数量</param> /// <param name="comparer">排序比较器</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数据</returns> public static subArray <valueType> GetRangeSort <valueType> (valueType[] values, int startIndex, int count, Func <valueType, valueType, int> comparer, int skipCount, int getCount) { array.range range = new array.range(values.length(), startIndex, count); if ((count = range.GetCount) != 0) { array.range getRange = new array.range(count, skipCount, getCount); if ((getCount = getRange.GetCount) != 0) { valueType[] newValues = new valueType[count]; Array.Copy(values, range.SkipCount, newValues, 0, count); return(RangeSort(newValues, comparer, getRange.SkipCount, getCount)); } } return(default(subArray <valueType>)); }
/// <summary> /// 压缩数据 /// </summary> /// <param name="data">原始数据</param> /// <param name="startIndex">起始位置</param> /// <param name="count">压缩字节数</param> /// <param name="seek">起始位置</param> /// <param name="memoryPool">数据缓冲区内存池</param> /// <returns>压缩后的数据,失败返回null</returns> public subArray <byte> GetCompress(byte[] data, int startIndex, int count, int seek = 0, memoryPool memoryPool = null) { if (seek >= 0) { if (count == 0) { return(subArray <byte> .Unsafe(nullValue <byte> .Array, 0, 0)); } array.range range = new array.range(data.length(), startIndex, count); if (count == range.GetCount) { return(GetCompressUnsafe(data, startIndex, count, seek, memoryPool)); } } log.Error.Throw(log.exceptionType.IndexOutOfRange); return(default(subArray <byte>)); }
/// <summary> /// 字节流转字符串 /// </summary> /// <param name="data">字节流</param> /// <param name="index">起始位置</param> /// <param name="length">字节数量</param> /// <param name="encoding">编码,检测失败为本地编码</param> /// <returns>字符串</returns> public unsafe static string toString(this byte[] data, int index, int length, Encoding encoding) { if (encoding != Encoding.ASCII) { return(encoding.GetString(data, index, length)); } array.range range = new array.range(data.length(), index, length); if (range.GetCount == length) { if (range.GetCount != 0) { fixed(byte *dataFixed = data) return(fastCSharp.String.UnsafeDeSerialize(dataFixed + range.SkipCount, -range.GetCount)); } return(string.Empty); } log.Error.Throw(log.exceptionType.IndexOutOfRange); return(null); }
/// <summary> /// 写字符串 /// </summary> /// <param name="value">字符串</param> /// <param name="index">起始位置</param> /// <param name="count">写入字符数</param> public unsafe void Write(string value, int index, int count) { array.range range = new array.range(value.length(), index, count); if (range.GetCount == count) { prepLength(count); fixed(char *dataFixed = array, valueFixed = value) { fastCSharp.unsafer.memory.Copy(valueFixed + index, dataFixed + Length, count); } Length += count; } else if (count != 0) { log.Default.Throw(log.exceptionType.IndexOutOfRange); } }
/// <summary> /// 获取排序数据范围集合 /// </summary> /// <param name="key">关键字</param> /// <param name="skipCount">跳过记录数</param> /// <param name="getCount">获取记录数</param> /// <returns>排序数据范围集合</returns> public valueType[] GetSort(keyType key, int skipCount, int getCount) { Monitor.Enter(cache.SqlTool.Lock); try { list <valueType> list = get(key); if (list != null) { array.range range = new array.range(list.Count, skipCount, getCount); if ((getCount = range.GetCount) != 0) { return(list.GetSub(range.SkipCount, range.GetCount)); } } } finally { Monitor.Exit(cache.SqlTool.Lock); } return(nullValue <valueType> .Array); }
/// <summary> /// 写数据 /// </summary> /// <param name="data">数据</param> /// <param name="index">起始位置</param> /// <param name="count">写入字节数</param> public void Write(byte[] data, int index, int count) { array.range range = new array.range(data.length(), index, count); if (range.GetCount == count) { prepLength(count); fixed(byte *dataFixed = data) { fastCSharp.unsafer.memory.Copy(dataFixed + range.SkipCount, this.data.Byte + length, count); } length += count; } else if (count != 0) { log.Error.Throw(log.exceptionType.IndexOutOfRange); } }
/// <summary> /// 范围排序 /// </summary> /// <param name="values">待排序数组</param> /// <param name="skipCount">跳过数据数量</param> /// <param name="getCount">排序数据数量</param> /// <returns>排序后的数据</returns> public unsafe static collection </*Type[0]*/ ulong /*Type[0]*/> RangeSort/*Compare[0]*//*Compare[0]*/ (/*Type[0]*/ ulong /*Type[0]*/[] values, int skipCount, int getCount) { array.range range = new array.range(values.length(), skipCount, getCount); if ((getCount = range.GetCount) != 0) { fixed(/*Type[0]*/ ulong /*Type[0]*/ *valueFixed = values) { new /*Type[1]*/ ulongRangeSorter/*Type[1]*//*Compare[0]*//*Compare[0]*/ { SkipCount = valueFixed + range.SkipCount, GetEndIndex = valueFixed + range.EndIndex - 1 }.Sort(valueFixed, valueFixed + values.Length - 1); } return(new collection </*Type[0]*/ ulong /*Type[0]*/>(values, range.SkipCount, getCount, true)); } return(null); }
/// <summary> /// 获取逆序数据范围集合 /// </summary> /// <param name="key">关键字</param> /// <param name="skipCount">跳过记录数</param> /// <param name="getCount">获取记录数</param> /// <returns>逆序数据范围集合</returns> public valueType[] GetSortDesc(keyType key, int skipCount, int getCount) { valueType[] values = null; Monitor.Enter(cache.SqlTool.Lock); try { list <valueType> list = get(key); if (list != null) { array.range range = new array.range(list.Count, skipCount, getCount); if ((getCount = range.GetCount) != 0) { values = list.GetSub(list.Count - range.SkipCount - range.GetCount, range.GetCount); } } } finally { Monitor.Exit(cache.SqlTool.Lock); } return(values.reverse()); }
/// <summary> /// 压缩数据 /// </summary> /// <param name="oldData">原始数据</param> /// <param name="type">压缩类型</param> /// <param name="startIndex">起始位置</param> /// <param name="count">压缩字节数</param> /// <returns>压缩后的数据,失败返回null</returns> public static byte[] getCompress(this byte[] oldData, compression type, int startIndex, int count) { array.range range = new array.range(oldData.length(), startIndex, count); if (count == range.GetCount) { using (MemoryStream dataStream = new MemoryStream()) { using (Stream compressStream = dataStream.toCompressStream(CompressionMode.Compress, true, type)) { compressStream.Write(oldData, startIndex, count); } if (dataStream.Position < oldData.Length) { if (dataStream.Length != dataStream.Position) dataStream.SetLength(dataStream.Position); return dataStream.ToArray(); } } return null; } else if (count == 0) return null; log.Default.Throw(log.exceptionType.IndexOutOfRange); return null; }
/// <summary> /// 解压缩数据 /// </summary> /// <param name="compressData">压缩数据</param> /// <param name="type">压缩类型</param> /// <param name="startIndex">起始位置</param> /// <param name="count">解压缩字节数</param> /// <returns>解压缩后的数据</returns> public static memoryStream getDeCompressStream(this byte[] compressData, compression type, int startIndex, int count) { array.range range = new array.range(compressData.length(), startIndex, count); if (count == range.GetCount) { using (Stream memoryStream = new MemoryStream(compressData, 0, compressData.Length)) using (Stream compressStream = memoryStream.toCompressStream(CompressionMode.Decompress, false, type)) { memoryStream dataStream = new memoryStream(compressData.Length); byte[] buffer = new byte[config.pub.Default.StreamBufferLength]; for (int readLength = compressStream.Read(buffer, 0, config.pub.Default.StreamBufferLength); readLength != 0; readLength = compressStream.Read(buffer, 0, config.pub.Default.StreamBufferLength)) { dataStream.Write(buffer, 0, readLength); } return dataStream; } } else if (count == 0) return null; log.Default.Throw(log.exceptionType.IndexOutOfRange); return null; }
/// <summary> /// 解压缩数据 /// </summary> /// <param name="compressData">压缩数据</param> /// <param name="startIndex">起始位置</param> /// <param name="count">解压缩字节数</param> /// <returns>解压缩后的数据</returns> public subArray<byte> GetDeCompress(byte[] compressData, int startIndex, int count, memoryPool memoryPool = null) { if (count > 0) { array.range range = new array.range(compressData.length(), startIndex, count); if (count == range.GetCount) return GetDeCompressUnsafe(compressData, range.SkipCount, count, memoryPool); } log.Error.Throw(log.exceptionType.IndexOutOfRange); return default(subArray<byte>); }
/// <summary> /// 字节流转字符串 /// </summary> /// <param name="data">字节流</param> /// <param name="index">起始位置</param> /// <param name="length">字节数量</param> /// <param name="encoding">编码,检测失败为本地编码</param> /// <returns>字符串</returns> public unsafe static string toString(this byte[] data, int index, int length, Encoding encoding) { if (encoding != Encoding.ASCII) return encoding.GetString(data, index, length); array.range range = new array.range(data.length(), index, length); if (range.GetCount == length) { if (range.GetCount != 0) { fixed (byte* dataFixed = data) return DeSerialize(dataFixed + range.SkipCount, -range.GetCount); } return string.Empty; } log.Default.Throw(log.exceptionType.IndexOutOfRange); return null; }
/// <summary> /// 分割字符串 /// </summary> /// <param name="value">原字符串</param> /// <param name="startIndex">起始位置</param> /// <param name="length">分割字符串长度</param> /// <param name="split">分割符</param> /// <returns>字符子串集合</returns> public unsafe static list<subString> split(this string value, int startIndex, int length, char split) { array.range range = new array.range(value.length(), startIndex, length); if (range.GetCount != length) fastCSharp.log.Default.Throw(log.exceptionType.IndexOutOfRange); list<subString> values = new list<subString>(); if (value != null) { fixed (char* valueFixed = value) { char* last = valueFixed + range.SkipCount, end = last + range.GetCount; for (char* start = last; start != end; ) { if (*start == split) { values.Add(new subString(value, (int)(last - valueFixed), (int)(start - last))); last = ++start; } else ++start; } values.Add(new subString(value, (int)(last - valueFixed), (int)(end - last))); } } return values; }
/// <summary> /// 字符子串 /// </summary> /// <param name="value">字符串</param> /// <param name="startIndex">起始位置</param> /// <param name="length">长度</param> public subString(string value, int startIndex, int length) { if (value == null) fastCSharp.log.Default.Throw(log.exceptionType.Null); array.range range = new array.range(value.Length, startIndex, length); if (range.GetCount != length) fastCSharp.log.Default.Throw(log.exceptionType.IndexOutOfRange); if (range.GetCount != 0) { this.value = value; this.startIndex = range.SkipCount; this.length = range.GetCount; } else { this.value = string.Empty; this.startIndex = this.length = 0; } }
/// <summary> /// 写字符串 /// </summary> /// <param name="value">字符串</param> /// <param name="index">起始位置</param> /// <param name="count">写入字符数</param> public unsafe void Write(string value, int index, int count) { array.range range = new array.range(value.length(), index, count); if (range.GetCount == count) { prepLength(count); fixed (char* dataFixed = array, valueFixed = value) { fastCSharp.unsafer.memory.Copy(valueFixed + index, dataFixed + Length, count); } Length += count; } else if (count != 0) log.Default.Throw(log.exceptionType.IndexOutOfRange); }