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