private unsafe void serialize(AutoCSer.BinarySerializer serializer)
{
int size = Buffer.Length;
if (IsClient)
{
serializer.Stream.Write(-size);
}
else
{
UnmanagedStream stream = serializer.Stream;
if (size == 0)
{
byte *write = stream.GetBeforeMove(sizeof(int) * 2);
*(int *)write = size;
*(int *)(write + sizeof(int)) = (int)(byte)State;
}
else
{
int offset = -size & 3;
byte *write = stream.GetBeforeMove(size + offset + sizeof(int));
*(int *)write = size;
Buffer.CopyTo(new Span <byte>(write + sizeof(int), size));
}
}
}
/// <summary>
/// 自定义序列化输出
/// </summary>
/// <param name="serializer"></param>
internal void Serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
int count = Math.Min((stream.FreeSize - sizeof(int) * 2) / (sizeof(int) * 2), right), endRight = right - count;
if (endRight > 0)
{
//Thread.Sleep(0);
addCustomSerialize(new ClientCustomSerialize {
Output = this
});
}
else
{
wait.Set();
endRight = 0;
}
int size = (count * (sizeof(int) * 2)) + sizeof(int);
byte *write = stream.Current;
*(int *)write = size;
write += sizeof(int);
while (right != endRight)
{
*(int *)write = left;
*(int *)(write + sizeof(int)) = --right;
write += sizeof(int) * 2;
}
stream.MoveSize(size);
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
stream.Write(Identity);
Parameter.SerializeReturnParameter(stream);
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
Serializer operationSerializer = new Serializer(serializer.Stream, ShortPathIdentity.SerializeSize + sizeof(int));
Node.SerializeParameter(operationSerializer.Stream);
operationSerializer.End(Node.Parameter.OperationType);
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
Serializer operationSerializer = new Serializer(serializer.Stream);
Node.SerializeParameter(operationSerializer.Stream);
operationSerializer.End(Node.Parameter.OperationType);
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
Serializer operationSerializer = new Serializer(serializer.Stream);
operationSerializer.Stream.Data.CurrentIndex += IndexIdentity.SerializeSize;
fixed(char *nameFixed = CacheName) AutoCSer.BinarySerializer.Serialize(nameFixed, operationSerializer.Stream, CacheName.Length);
operationSerializer.End(OperationType.RemoveDataStructure);
}
private unsafe void serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
byte * write = stream.GetBeforeMove(sizeof(ulong) * 4);
*(ulong *)write = Ticks;
*(ulong *)(write + sizeof(ulong)) = Identity;
*(ulong *)(write + sizeof(ulong) * 2) = Low;
*(ulong *)(write + sizeof(ulong) * 3) = High;
}
private unsafe void serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
int size = Buffer.Length, offset = -(size + sizeof(ushort)) & 3;
byte * write = stream.GetBeforeMove(size + offset + (sizeof(int) + sizeof(ulong) + sizeof(ushort)));
*(int *)write = size;
*(ulong *)(write + sizeof(int)) = Index;
Buffer.CopyTo(new Span <byte>(write + (sizeof(int) + sizeof(ulong)), size));
*(ushort *)(write + (size + (sizeof(int) + sizeof(ulong)))) = BlockIndex;
}
private static void serialize(AutoCSer.BinarySerializer serializer, ReturnValue value)
{
if (value == null)
{
serializer.Stream.Write(AutoCSer.BinarySerializer.NullValue);
}
else
{
value.serialize(serializer);
}
}
protected void serializeParent(AutoCSer.BinarySerializer serializer, ServerNodeIdChecker checker)
{
if (Parent == null)
{
serializer.Stream.Write(AutoCSer.BinarySerializer.NullValue);
}
else
{
Parent.Serialize(serializer, checker);
}
}
protected override void serializeParameter(AutoCSer.BinarySerializer serializer)
{
#region LOOP IntputParameters
#region IF ParameterType.IsNull
base.serializeParameter(serializer, @ParameterName);
#endregion IF ParameterType.IsNull
#region NOT ParameterType.IsNull
base.serializeParameterStruct(serializer, ref @ParameterName);
#endregion NOT ParameterType.IsNull
#endregion LOOP IntputParameters
}
protected void serializeParameter <parameterType>(AutoCSer.BinarySerializer serializer, parameterType parameter)
{
if (parameter == null)
{
serializer.Stream.Write(AutoCSer.BinarySerializer.NullValue);
}
else
{
AutoCSer.BinarySerialize.TypeSerializer <parameterType> .ClassSerialize(serializer, parameter);
}
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
int valueLength = Data.Length;
byte * data = stream.GetBeforeMove((valueLength + (sizeof(int) + 3)) & (int.MaxValue - 3));
*(int *)data = valueLength;
fixed(byte *dataFixed = Data.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(dataFixed + Data.Start, data += sizeof(int), valueLength);
Reader.Next();
}
internal void Serialize(AutoCSer.BinarySerializer serializer)
{
if (MemberMap == null || MemberMap.IsDefault)
{
serializer.TypeSerialize(Value);
}
else
{
AutoCSer.BinarySerialize.SerializeMemberMap serializeMemberMap = serializer.GetCustomMemberMap(MemberMap);
try
{
serializer.TypeSerialize(Value);
}
finally { serializer.SetCustomMemberMap(ref serializeMemberMap); }
}
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
if (Getter != null)
{
Getter.Serialize(serializer.Stream);
}
else if (Buffer != null)
{
UnmanagedStream stream = serializer.Stream;
int startIndex = stream.AddSize(sizeof(int));
stream.Write(ref Buffer.Array);
*(int *)(stream.Data.Byte + (startIndex - sizeof(int))) = stream.Data.CurrentIndex - startIndex;
Buffer.FreeReference();
}
else
{
serializer.Stream.Write(AutoCSer.BinarySerializer.NullValue);
}
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
new AutoCSer.Metadata.MemberMapValue <memberMapType> {
MemberMap = MemberMap, Value = Value
}.Serialize(serializer);
}
/// <summary>
/// 服务端序列化返回值
/// </summary>
/// <param name="serializer"></param>
protected virtual void serialize(AutoCSer.BinarySerializer serializer)
{
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
Parameter.SerializeReturnParameter(serializer.Stream);
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
DataStructure.SerializeOperationParameter(serializer.Stream);
}
/// <summary>
/// 客户端序列化
/// </summary>
/// <param name="serializer"></param>
protected virtual void serializeParameter(AutoCSer.BinarySerializer serializer)
{
}
/// <summary>
/// 序列化操作
/// </summary>
/// <param name="serializer"></param>
internal void Serialize(AutoCSer.BinarySerializer serializer)
{
UnmanagedStream stream = serializer.Stream;
byte * start = stream.Current, write = start + sizeof(int);
int freeCount = (stream.FreeSize - sizeof(int) * 2) / (sizeof(int) * 3), outputCount = 0;
ServerCustomSerializeBuffer buffer;
do
{
while (System.Threading.Interlocked.CompareExchange(ref bufferLock, 1, 0) != 0)
{
AutoCSer.Threading.ThreadYield.Yield();
}
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);
while (System.Threading.Interlocked.CompareExchange(ref bufferLock, 1, 0) != 0)
{
AutoCSer.Threading.ThreadYield.Yield();
}
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);
while (System.Threading.Interlocked.CompareExchange(ref freeBufferLock, 1, 0) != 0)
{
AutoCSer.Threading.ThreadYield.Yield();
}
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);
}
private void serialize(AutoCSer.BinarySerializer serializer)
{
serializer.Stream.Write(ClientNodeId);
Node.Serialize(serializer, Checker);
}
internal void Serialize(AutoCSer.BinarySerializer serializer)
{
serializer.TypeSerialize(Value == null ? 1 : 2);
}
internal void Serialize(AutoCSer.BinarySerializer serializer, ServerNodeIdChecker checker)
{
serializer.Stream.Write(checker.ServerNodeIds[GetType()]);
serializeParameter(serializer);
serializeParent(serializer, checker);
}
private unsafe void serialize(AutoCSer.BinarySerializer serializer)
{
Output.Serialize(serializer);
}
internal static void Serialize(AutoCSer.BinarySerializer serializer, CustomClass value)
{
serializer.Stream.Write(value.Value == null ? 1 : 2);
}
protected void serializeParameterStruct <parameterType>(AutoCSer.BinarySerializer serializer, ref parameterType parameter)
{
AutoCSer.BinarySerialize.TypeSerializer <parameterType> .StructSerialize(serializer, ref parameter);
}
