private unsafe static void serialize(fastCSharp.emit.dataSerializer serializer, fileBlockMember <valueType> value)
{
int indexCustom = value.index.Custom;
if ((indexCustom & (int)custom.Serialize) == 0)
{
if (value.index.Size == 0)
{
serializer.Stream.Write(fastCSharp.emit.binarySerializer.NullValue);
}
else
{
unmanagedStream stream = serializer.Stream;
stream.PrepLength(sizeof(int) * 2 + sizeof(long));
byte *data = stream.CurrentData;
*(int *)data = (emit.pub.PuzzleValue & 0x7fffff00) + indexCustom;
*(int *)(data + sizeof(int)) = value.index.Size;
*(long *)(data + sizeof(int) * 2) = value.index.Index;
stream.UnsafeAddLength(sizeof(int) * 2 + sizeof(long));
stream.PrepLength();
}
}
else if (value.value == null)
{
serializer.Stream.Write(fastCSharp.emit.binarySerializer.NullValue);
}
else
{
serializer.Stream.Write(indexCustom);
fastCSharp.emit.dataSerializer.typeSerializer <valueType> .Serialize(serializer, value.value);
}
}
/// <summary>
/// 文本转HTML
/// </summary>
/// <param name="value">文本值</param>
/// <param name="stream">HTML编码流</param>
public unsafe void ToHtml(ref subString value, unmanagedStream stream)
{
if (value.Length != 0)
{
if (stream == null)
{
log.Error.Throw(log.exceptionType.Null);
}
int length = value.Length;
fixed(char *valueFixed = value.value)
{
char *start = valueFixed + value.StartIndex, end = start + length;
int count = encodeCount(start, end);
if (count == 0)
{
stream.PrepLength(length <<= 1);
unsafer.memory.Copy(start, stream.CurrentData, length);
}
else
{
length += count << 2;
stream.PrepLength(length <<= 1);
toHtml(start, end, (char *)stream.CurrentData);
}
stream.UnsafeAddLength(length);
}
}
}
/// <summary>
/// 格式化ajax字符串
/// </summary>
/// <param name="jsStream">JS字符流</param>
/// <param name="formatStream">格式化JSON字符流</param>
internal unsafe static void FormatJavascript(charStream jsStream, unmanagedStream formatStream)
{
if (jsStream.Length != 0)
{
char *start = jsStream.Char;
int length = formatLength(jsStream);
if (length == 0)
{
char *end = start + (length = jsStream.Length);
formatStream.PrepLength(length <<= 1);
for (char *write = (char *)(formatStream.CurrentData); start != end; ++start)
{
*write++ = *start == Quote ? '"' : *start;
}
formatStream.UnsafeAddLength(length);
}
else
{
length += jsStream.Length;
formatStream.PrepLength(length <<= 1);
formatJavascript(start, start + jsStream.Length, (char *)(formatStream.CurrentData));
formatStream.UnsafeAddLength(length);
}
}
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream"></param>
/// <param name="map"></param>
/// <param name="fieldCount"></param>
internal static void FieldSerialize(unmanagedStream stream, ulong map, int fieldCount)
{
if (map == 0)
{
stream.Write(0);
}
else
{
stream.PrepLength(sizeof(int) + sizeof(ulong));
byte *data = stream.CurrentData;
*(int *)data = fieldCount;
*(ulong *)(data + sizeof(int)) = map;
stream.UnsafeAddLength(sizeof(int) + sizeof(ulong));
stream.PrepLength();
}
}
/// <summary>
/// 中文分词词语集合写入文本文件
/// </summary>
private unsafe static void writeTxtFile()
{
string[] words = Words;
using (unmanagedStream wordStream = new unmanagedStream())
{
*(int *)wordStream.Data = words.Length;
wordStream.UnsafeAddLength(sizeof(int));
foreach (string word in words)
{
wordStream.Write(word);
wordStream.Write((char)0);
}
subArray <byte> data = io.compression.stream.Deflate.GetCompress(wordStream.GetArray(), 0);
using (FileStream fileStream = new FileStream(fastCSharp.config.search.Default.WordTxtFileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
fileStream.Write(data.UnsafeArray, data.StartIndex, data.Count);
}
}
}
/// <summary>
/// 保存TCP服务信息集合到缓存文件
/// </summary>
internal unsafe void SaveCacheFile()
{
cache cache = new cache();
byte[] buffer = fastCSharp.memoryPool.StreamBuffers.Get();
try
{
fixed(byte *bufferFixed = buffer)
{
using (unmanagedStream stream = new unmanagedStream(bufferFixed, buffer.Length))
{
Monitor.Enter(serviceLock);
try
{
cache.Services = serviceCache.Values.getArray();
cache.HostPorts = hostPorts.getArray(value => new keyValue <string, int>(value.Key.ToString(), value.Value));
fastCSharp.emit.dataSerializer.Serialize(cache, stream);
if (stream.data.data == bufferFixed)
{
using (FileStream file = new FileStream(cacheFile, FileMode.Create, FileAccess.Write, FileShare.None))
{
file.Write(buffer, 0, stream.Length);
}
}
else
{
File.WriteAllBytes(cacheFile, stream.GetArray());
}
}
finally
{
isSaveCacheFile = 0;
Monitor.Exit(serviceLock);
}
}
}
}
finally { fastCSharp.memoryPool.StreamBuffers.PushNotNull(buffer); }
}
/// <summary>
/// 获取解压数据
/// </summary>
/// <returns>解压数据</returns>
public unsafe subArray <byte> Get(memoryPool memoryPool)
{
if (memoryPool == null)
{
pointer data = fastCSharp.unmanagedPool.StreamBuffers.Get();
try
{
using (dataStream = new unmanagedStream(data.Byte, fastCSharp.unmanagedPool.StreamBuffers.Size))
{
get();
return(new subArray <byte>(dataStream.GetArray()));
}
}
finally { fastCSharp.unmanagedPool.StreamBuffers.Push(ref data); }
}
else
{
byte[] data = memoryPool.Get();
try
{
fixed(byte *dataFixed = data)
{
using (dataStream = new unmanagedStream(dataFixed, data.Length))
{
get();
if (dataStream.data.data == dataFixed)
{
byte[] buffer = data;
data = null;
return(subArray <byte> .Unsafe(buffer, 0, dataStream.Length));
}
return(new subArray <byte>(dataStream.GetArray()));
}
}
}
finally { memoryPool.PushOnly(data); }
}
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream"></param>
/// <param name="map"></param>
/// <param name="type"></param>
internal static void FieldSerialize(unmanagedStream stream, byte *map, type type)
{
if (map == null)
{
stream.Write(0);
}
else
{
stream.PrepLength(type.FieldSerializeSize + sizeof(int));
byte *data = stream.CurrentData, read = map;
*(int *)data = type.FieldCount;
data += sizeof(int);
for (byte *end = map + (type.FieldSerializeSize & (int.MaxValue - sizeof(ulong) + 1)); read != end; read += sizeof(ulong), data += sizeof(ulong))
{
*(ulong *)data = *(ulong *)read;
}
if ((type.FieldSerializeSize & sizeof(int)) != 0)
{
*(uint *)data = *(uint *)read;
}
stream.UnsafeAddLength(type.FieldSerializeSize + sizeof(int));
stream.PrepLength();
}
}
/// <summary> /// 字段成员序列化 /// </summary> /// <param name="stream"></param> internal abstract void FieldSerialize(unmanagedStream stream);
/// <summary>
/// 获取C#计算哈希代码
/// </summary>
/// <param name="keyName">关键字变量名称</param>
/// <returns>C#计算哈希代码</returns>
public unsafe string Code(string keyName = "key")
{
if (indexs == null)
{
return(string.Empty);
}
using (unmanagedStream code = new unmanagedStream())
{
if (indexs.Length == 0)
{
code.Write(@"fixed (char* keyFixed = ");
code.Write(keyName);
code.Write(@")
{
");
}
code.Write(" uint code = ");
bool isFirst = true;
if (indexs.Length == 0)
{
code.Write("(uint)fastCSharp.algorithm.hashCode.GetHashCode(keyFixed, ");
code.Write(keyName);
code.Write(@" << 1)");
}
else
{
int shiftBit = bit * (indexs.Length - 1);
foreach (index index in indexs)
{
if (isFirst)
{
isFirst = false;
}
else
{
code.Write(" + ");
}
code.Write("(uint)");
if (shiftBit != 0)
{
code.Write('(');
}
if (sub != 0)
{
code.Write('(');
}
code.Write(keyName);
code.Write('[');
switch (index.Type)
{
case index.type.Left:
code.Write(index.Index.toString());
break;
case index.type.Right:
code.Write(keyName);
code.Write(".Length - ");
code.Write((index.Index + 1).toString());
break;
default:
code.Write(keyName);
code.Write(".Length >> ");
code.Write(index.Index.toString());
break;
}
code.Write(']');
if (sub != 0)
{
code.Write(" - ");
code.Write(sub.toString());
code.Write(')');
}
if (shiftBit != 0)
{
code.Write(" << ");
code.Write(shiftBit.toString());
code.Write(')');
shiftBit -= bit;
}
}
}
code.Write(@";
return (int)((");
isFirst = true;
foreach (int shift in shifts)
{
if (isFirst)
{
isFirst = false;
}
else
{
code.Write(" ^ ");
}
if (shift != 0)
{
code.Write('(');
}
code.Write("code");
if (shift != 0)
{
code.Write(" >> ");
code.Write(shift.toString());
code.Write(')');
}
}
code.Write(") & ((1U << ");
code.Write(minSize.toString());
code.Write(") - 1))");
if (!isMaxCode && minCode != 0)
{
code.Write(" - ");
code.Write(minCode.toString());
}
code.Write(';');
if (indexs.Length == 0)
{
code.Write(@"
}");
}
return(code.ToString());
}
}
/// <summary>
/// 写入文件数据
/// </summary>
/// <param name="stream">文件数据流</param>
/// <returns>是否成功</returns>
public unsafe bool Write(unmanagedStream stream)
{
try
{
if (fileWriter.UnsafeWrite(stream.Data, stream.Length) >= 0) return true;
dispose(fileWriter.LastException);
}
catch (Exception error)
{
dispose(error);
}
return false;
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="webSocket"></param>
internal unsafe void Send(webSocket.socket webSocket)
{
byte[] buffer = fastCSharp.memoryPool.StreamBuffers.Get();
webSocket.socket.message message = default(webSocket.socket.message);
try
{
fixed(byte *bufferFixed = buffer)
{
using (unmanagedStream stream = new unmanagedStream(bufferFixed, buffer.Length))
{
sender sender = new sender {
Buffer = buffer, BufferFixed = bufferFixed, Stream = stream
};
do
{
if (webSocket == this.WebSocket && webSocket.SocketIdentity == socket.identity)
{
if (webSocket.GetMessage(ref message))
{
sender.Send(ref message);
if ((stream.Length << 1) > buffer.Length)
{
byte[] data = sender.GetData();
Monitor.Enter(sendLock);
try
{
webSocket.SslStream.Write(data, 0, stream.Length);
++socket.timeoutIdentity;
}
finally { Monitor.Exit(sendLock); }
stream.UnsafeSetLength(0);
}
else if (webSocket.MessageCount == 0)
{
Thread.Sleep(0);
}
}
else
{
if (stream.Length != 0)
{
byte[] data = sender.GetData();
Monitor.Enter(sendLock);
try
{
webSocket.SslStream.Write(data, 0, stream.Length);
++socket.timeoutIdentity;
}
finally { Monitor.Exit(sendLock); }
}
return;
}
}
else
{
break;
}
}while (true);
}
}
}
catch { }
finally { fastCSharp.memoryPool.StreamBuffers.PushNotNull(buffer); }
webSocket.Client.shutdown();
}
/// <summary>
/// 对象序列化器
/// </summary>
/// <param name="isReferenceMember">是否检测相同的引用成员</param>
/// <param name="stream">序列化流</param>
/// <param name="memberFilter">成员选择</param>
public reflectionDataSerializer(bool isReferenceMember, unmanagedStream stream, code.memberFilters memberFilter)
: base(isReferenceMember, stream, memberFilter)
{
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="isReferenceMember">是否检测相同的引用成员</param>
/// <param name="stream">序列化流</param>
/// <param name="memberFilter">成员选择</param>
protected serializer(bool isReferenceMember, unmanagedStream stream, code.memberFilters memberFilter)
: base(isReferenceMember, stream, memberFilter)
{
}
/// <summary>
/// 可空类型
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="serializer">反序列化器</param>
/// <returns>可空类型数据</returns>
private static void getNullType <valueType>(unmanagedStream stream, Nullable <valueType> value) where valueType : struct
{
Get <valueType>(stream, value.Value, code.memberFilters.InstanceField, default(memberMap <valueType>));
}
/// <summary>
/// 序列化接口
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="stream">内存数据流</param>
/// <param name="value">序列化接口数据</param>
private static void getISerializeType <valueType>(unmanagedStream stream, valueType value) where valueType : ISerialize
{
value.IndexSerialize(stream);
}
/// <summary>
/// 对象序列化
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <param name="stream">内存数据流</param>
/// <param name="value">数据对象</param>
/// <param name="filter">成员选择,默认为公共字段成员</param>
/// <param name="memberMap">成员位图</param>
public static void Get <valueType>(unmanagedStream stream, valueType value
, code.memberFilters filter = code.memberFilters.InstanceField, memberMap <valueType> memberMap = default(memberMap <valueType>))
{
dataSerialize <valueType> .Get(stream, value, filter, memberMap);
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream"></param>
internal override void FieldSerialize(unmanagedStream stream)
{
memberMap.FieldSerialize(stream, map, TypeInfo);
}
/// <summary>
/// 获取解压数据
/// </summary>
/// <returns>解压数据</returns>
public unsafe subArray<byte> Get(memoryPool memoryPool)
{
if (memoryPool == null)
{
pointer data = fastCSharp.unmanagedPool.StreamBuffers.Get();
try
{
using (dataStream = new unmanagedStream(data.Byte, fastCSharp.unmanagedPool.StreamBuffers.Size))
{
get();
return new subArray<byte>(dataStream.GetArray());
}
}
finally { fastCSharp.unmanagedPool.StreamBuffers.Push(ref data); }
}
else
{
byte[] data = memoryPool.Get();
try
{
fixed (byte* dataFixed = data)
{
using (dataStream = new unmanagedStream(dataFixed, data.Length))
{
get();
if (dataStream.Data == dataFixed)
{
byte[] buffer = data;
data = null;
return subArray<byte>.Unsafe(buffer, 0, dataStream.Length);
}
return new subArray<byte>(dataStream.GetArray());
}
}
}
finally { memoryPool.Push(ref data); }
}
}
