/// <summary>
/// 字符串序列化
/// </summary>
/// <param name="stream">序列化数据流</param>
/// <param name="array">数据,不能为null</param>
internal static void Serialize(UnmanagedStream stream, string[] array)
{
AutoCSer.BinarySerialize.SerializeArrayMap arrayMap = new AutoCSer.BinarySerialize.SerializeArrayMap(stream, array.Length, 0);
foreach (string value in array)
{
arrayMap.Next(value != null);
}
arrayMap.End(stream);
foreach (string value in array)
{
if (value != null)
{
if (value.Length == 0)
{
stream.Write(0);
}
else
{
fixed(char *valueFixed = value) AutoCSer.BinarySerialize.Serializer.Serialize(valueFixed, stream, value.Length);
}
}
}
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) * 3)
{
CommandBase nextBuild = LinkNext;
byte * write = stream.CurrentData;
*(int *)write = Server.CancelKeepCommandIndex;
*(int *)(write + sizeof(int)) = cancelCommandIndex;
*(int *)(write + (sizeof(uint) + sizeof(int))) = 0;
stream.ByteSize += sizeof(int) * 3;
++buildInfo.Count;
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <CancelKeepCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) + sizeof(uint))
{
byte * write = stream.CurrentData;
CommandBase nextBuild = LinkNext;
*(int *)write = CommandInfo.Command;
//*(uint*)(write + sizeof(int)) = (CommandIndex & Server.CommandIndexAnd) | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData);
*(uint *)(write + sizeof(int)) = (uint)(CommandInfo.CommandFlags | CommandFlags.NullData);
++buildInfo.Count;
stream.ByteSize += sizeof(int) + sizeof(uint);
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <SendOnlyCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>下一个命令</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint))
{
CommandBase nextBuild = LinkNext;
int commandIndex = Socket.CommandPool.Push(this);
if (commandIndex != 0)
{
stream.Data.Write(CommandInfo.Command, (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData));
++buildInfo.Count;
LinkNext = null;
return(nextBuild);
}
LinkNext = null;
OutputParameter.Type = ReturnType.ClientBuildError;
setTask();
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 设置输出数据
/// </summary>
/// <param name="bodyStream"></param>
internal unsafe void SetBody(UnmanagedStream bodyStream)
{
if (bodyStream.ByteSize == 0)
{
SetBody();
}
else
{
freeBody();
bodyStream.GetSubBuffer(ref SubBuffer, 0);
if (SubBuffer.PoolBuffer.Pool == null)
{
Body.Array = SubBuffer.Buffer;
Type = ResponseType.ByteArray;
SubBuffer.Buffer = null;
}
else
{
Body.Set(SubBuffer.Buffer, SubBuffer.StartIndex, bodyStream.ByteSize);
Type = ResponseType.SubBuffer;
}
}
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="stream"></param>
internal void BinarySerialize(UnmanagedStream stream)
{
if (map == null)
{
stream.Write(0);
}
else
{
stream.PrepLength(Type.BinarySerializeSize + sizeof(int));
byte *data = stream.CurrentData, read = map;
*(int *)data = Type.FieldCount;
data += sizeof(int);
for (byte *end = map + (Type.BinarySerializeSize & (int.MaxValue - sizeof(ulong) + 1)); read != end; read += sizeof(ulong), data += sizeof(ulong))
{
*(ulong *)data = *(ulong *)read;
}
if ((Type.BinarySerializeSize & sizeof(int)) != 0)
{
*(uint *)data = *(uint *)read;
}
stream.ByteSize += Type.BinarySerializeSize + sizeof(int);
//stream.PrepLength();
}
}
/// <summary>
/// 创建输出信息
/// </summary>
/// <param name="sender">TCP 服务套接字数据发送</param>
/// <param name="buildInfo">输出创建参数</param>
internal override OutputLink Build(TcpServer.ServerSocketSenderBase sender, ref TcpServer.SenderBuildInfo buildInfo)
{
UnmanagedStream stream = sender.OutputSerializer.Stream;
if (stream.ByteSize == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= outputInfo.MaxDataSize)
{
ulong markData = sender.ServerSocket.MarkData;
int streamLength = stream.ByteSize;
OutputLink nextBuild = LinkNext;
stream.PrepLength(sizeof(int) * 2);
stream.ByteSize += sizeof(int);
if (outputInfo.IsJsonSerialize == 0)
{
sender.Serialize(outputInfo, ref outputParameter);
}
else
{
sender.JsonSerialize(ref outputParameter);
}
int dataLength = stream.ByteSize - streamLength - sizeof(int);
byte *dataStart = stream.Data.Byte + streamLength;
*(int *)dataStart = dataLength + OutputDataSize;
if (markData != 0)
{
TcpServer.CommandBase.Mark(dataStart + sizeof(int), markData, dataLength);
}
outputInfo.CheckMaxDataSize(Math.Max(dataLength + sizeof(int), stream.LastPrepSize - streamLength));
LinkNext = null;
outputParameter = default(outputParameterType);
AutoCSer.Threading.RingPool <Output <outputParameterType> > .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 缓存快照
/// </summary>
/// <param name="cache">缓存管理</param>
/// <param name="isLoadArraySize"></param>
internal Cache(AutoCSer.CacheServer.CacheManager cache, bool isLoadArraySize)
{
if (cache.Array.Length != 0)
{
dataStructures = cache.DataStructures.Values
.getLeftArray(value => new ServerDataStructure(value))
.GetSortDesc(value => value.Identity.Index);
if (isLoadArraySize)
{
array = cache.Array.copy();
cache.FreeIndexs.SortDesc();
step = 1;
}
else
{
step = 2;
}
stream = new UnmanagedStream(64 << 10);
}
else
{
step = 4;
}
}
internal void FreeSerializer()
{
OutputStream = null;
if (ReceiveDeSerializer != null)
{
ReceiveDeSerializer.Free();
ReceiveDeSerializer = null;
}
if (ReceiveJsonParser != null)
{
ReceiveJsonParser.Free();
ReceiveJsonParser = null;
}
if (OutputSerializer != null)
{
OutputSerializer.Free();
OutputSerializer = null;
}
if (OutputJsonSerializer != null)
{
OutputJsonSerializer.Free();
OutputJsonSerializer = null;
}
}
/// <summary>
/// 序列化数据
/// </summary>
/// <param name="stream"></param>
internal unsafe void Serialize(UnmanagedStream stream)
{
int startIndex;
switch (step)
{
case CacheGetStep.Snapshot:
startIndex = stream.AddSize(sizeof(int));
snapshot.CopyTo(stream);
do
{
snapshotSize = snapshot.NextSize();
}while (snapshotSize != 0 && snapshot.TryCopyTo(stream));
timeout = Date.Now.AddTicks(timeoutTicks);
*(int *)(stream.Data.Byte + (startIndex - sizeof(int))) = stream.ByteSize - startIndex;
if (snapshotSize != 0)
{
if (!onCache.Callback(new CacheReturnParameter {
Getter = this
}))
{
error();
*(int *)(stream.Data.Byte + (startIndex - sizeof(int))) = AutoCSer.BinarySerialize.Serializer.NullValue;
stream.ByteSize = startIndex;
}
return;
}
snapshot = null;
step = CacheGetStep.TcpQueue;
Cache.TcpServer.CallQueue.Add(new ServerCall.CacheGetterGetQueue(this));
return;
case CacheGetStep.TcpQueue:
startIndex = stream.AddSize(sizeof(int));
currentQueue.CopyTo(stream);
do
{
currentQueue = currentQueue.LinkNext;
}while (currentQueue != null && currentQueue.TryCopyTo(stream));
timeout = Date.Now.AddTicks(timeoutTicks);
*(int *)(stream.Data.Byte + (startIndex - sizeof(int))) = stream.ByteSize - startIndex;
if (currentQueue != null)
{
if (!onCache.Callback(new CacheReturnParameter {
Getter = this
}))
{
error();
*(int *)(stream.Data.Byte + (startIndex - sizeof(int))) = AutoCSer.BinarySerialize.Serializer.NullValue;
stream.ByteSize = startIndex;
}
return;
}
Cache.TcpServer.CallQueue.Add(new ServerCall.CacheGetterGetQueue(this));
return;
case CacheGetStep.Loaded: stream.Write(0); return;
case CacheGetStep.Error: stream.Write(AutoCSer.BinarySerialize.Serializer.NullValue); return;
}
}
/// <summary> /// 数据序列化 /// </summary> /// <param name="stream"></param> internal abstract void Serialize(UnmanagedStream stream);
protected void repsonseCall <callType>(callType call, ref UnmanagedStream responseStream)
where callType : AutoCSer.WebView.Call <callType>
{
call.RepsonseEnd(ref responseStream);
}
protected void repsonseCall(AutoCSer.WebView.Call call, ref UnmanagedStream responseStream)
{
call.RepsonseEnd(ref responseStream);
}
/// <summary> /// 序列化数据结构定义信息 /// </summary> /// <param name="stream"></param> internal abstract void SerializeDataStructure(UnmanagedStream stream);
/// <summary>
/// 序列化操作
/// </summary>
/// <param name="serializer"></param>
internal void Serialize(AutoCSer.BinarySerialize.Serializer serializer)
{
UnmanagedStream stream = serializer.Stream;
byte * start = stream.CurrentData, write = start + sizeof(int);
int freeCount = (stream.FreeSize - sizeof(int) * 2) / (sizeof(int) * 3), outputCount = 0;
ServerCustomSerializeBuffer buffer;
do
{
AutoCSer.Threading.Interlocked.CompareExchangeYield(ref bufferLock);
if (headBuffer == null)
{
buffer = currentBuffer;
currentBuffer = null;
System.Threading.Interlocked.Exchange(ref bufferLock, 0);
if (buffer == null)
{
Interlocked.Exchange(ref isOutput, 0);
if ((headBuffer == null && currentBuffer == null) || Interlocked.CompareExchange(ref isOutput, 1, 0) != 0)
{
stream.MoveSize(*(int *)start = (outputCount * (sizeof(int) * 3)) + sizeof(int));
return;
}
continue;
}
}
else
{
buffer = headBuffer;
if ((headBuffer = headBuffer.LinkNext) == null)
{
headBuffer = endBuffer = null;
System.Threading.Interlocked.Exchange(ref bufferLock, 0);
}
else
{
System.Threading.Interlocked.Exchange(ref bufferLock, 0);
buffer.LinkNext = null;
}
}
int bufferCount = buffer.Size / (sizeof(int) * 2);
if (bufferCount > freeCount)
{
onCustomSerialize.Callback(new ServerCustomSerialize {
Output = this
});
write = buffer.Serialize(write, freeCount);
AutoCSer.Threading.Interlocked.CompareExchangeYield(ref bufferLock);
if (headBuffer == null)
{
endBuffer = buffer;
}
else
{
buffer.LinkNext = headBuffer;
}
headBuffer = buffer;
System.Threading.Interlocked.Exchange(ref bufferLock, 0);
stream.MoveSize(*(int *)start = ((outputCount + freeCount) * (sizeof(int) * 3)) + sizeof(int));
return;
}
write = buffer.Serialize(write);
AutoCSer.Threading.Interlocked.CompareExchangeYield(ref freeBufferLock);
buffer.LinkNext = freeBuffer;
freeBuffer = buffer;
System.Threading.Interlocked.Exchange(ref freeBufferLock, 0);
outputCount += bufferCount;
if ((freeCount -= bufferCount) == 0)
{
stream.MoveSize(*(int *)start = (outputCount * (sizeof(int) * 3)) + sizeof(int));
if (headBuffer == null && currentBuffer == null)
{
Interlocked.Exchange(ref isOutput, 0);
if ((headBuffer == null && currentBuffer == null) || Interlocked.CompareExchange(ref isOutput, 1, 0) != 0)
{
return;
}
}
onCustomSerialize.Callback(new ServerCustomSerialize {
Output = this
});
return;
}
}while (true);
}
public unsafe static DeSerializeResult deSerialize <valueType>(this valueType value, UnmanagedStream data, int startIndex = 0, DeSerializeConfig config = null)
{
if (data == null)
{
return new DeSerializeResult {
State = DeSerializeState.UnknownData
}
}
;
return(DeSerializer.DeSerialize <valueType>(null, data.Data.Byte + startIndex, data.ByteSize - startIndex, ref value, config));
}
internal void CopyTo(UnmanagedStream stream)
{
stream.WriteNotEmpty(this.stream.Data.Byte, this.stream.Data.CurrentIndex);
}
private static void enumULong <valueType>(UnmanagedStream stream, valueType value)
{
stream.UnsafeWrite(Emit.EnumCast <valueType, ulong> .ToInt(value));
}
private static void serialize(UnmanagedStream stream, sbyte value)
{
stream.Data.Write(value);
}
private static void enumShort <valueType>(UnmanagedStream stream, valueType value)
{
stream.UnsafeWrite(Emit.EnumCast <valueType, short> .ToInt(value));
}
private static void serialize(UnmanagedStream stream, Guid value)
{
stream.Data.Write(ref value);
}
private static void serialize(UnmanagedStream stream, bool?value)
{
stream.Data.Write(value.HasValue ? ((bool)value ? (byte)2 : (byte)1) : (byte)0);
}
public void ResetReadFault()
{
UnmanagedStream bs = new UnmanagedStream();
Assert.Catch <InvalidOperationException>(() => { bs.ResetRead(); });
}
/// <summary>
/// 序列化数据结构定义信息
/// </summary>
/// <param name="stream"></param>
internal override void SerializeDataStructure(UnmanagedStream stream)
{
stream.Write((ushort)((byte)Abstract.NodeType.Value + ((int)(byte)ValueData.DataType.BinarySerialize << 8)));
serializeParentDataStructure(stream);
}
/// <summary>
/// 序列化数据结构定义信息
/// </summary>
/// <param name="stream"></param>
internal override void SerializeDataStructure(UnmanagedStream stream)
{
stream.Write((byte)Abstract.NodeType.FragmentDictionary);
stream.Write((byte)ValueData.Data <keyType> .DataType);
serializeParentDataStructure(stream);
}
internal void CopyTo(UnmanagedStream stream)
{
stream.Write(ref Array);
FreeReference();
}
/// <summary>
/// 序列化数据结构定义信息
/// </summary>
/// <param name="stream"></param>
internal override void SerializeDataStructure(UnmanagedStream stream)
{
stream.Write((byte)Abstract.NodeType.Array);
serializeParentDataStructure(stream);
}
/// <summary>
/// WEB 调用同步处理
/// </summary>
/// <param name="call"></param>
/// <param name="responseStream"></param>
/// <returns></returns>
protected virtual bool call(AutoCSer.WebView.CallBase call, ref UnmanagedStream responseStream)
{
return(false);
}
/// <summary>
/// 序列化数据结构定义信息
/// </summary>
/// <param name="stream"></param>
internal override void SerializeDataStructure(UnmanagedStream stream)
{
stream.Write((byte)Abstract.NodeType.MessageQueueConsumer);
stream.Write((byte)ValueData.Data <valueType> .DataType);
serializeParentDataStructure(stream);
}
internal void UnsafeSerialize(UnmanagedStream stream)
{
UnsafeSerialize(stream.CurrentData);
stream.ByteSize += SerializeSize;
}
