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