public RabbitMqServiceOptionsBuilder WithDefaultSerializer(SerializerDelegate serializer, string?contentType) { _serializer = serializer; _contentType = contentType; return(this); }
public MyTerminalControlTextbox(string id, MyStringId title, MyStringId tooltip) : base(id) { Title = title; Tooltip = tooltip; Serializer = (s, sb) => s.Serialize(sb, ref m_tmpArray, Encoding.UTF8); }
protected bool CreateAndWriteRequest <TRequest>( NetDataWriter writer, ushort requestType, TRequest request, SerializerDelegate extraRequestSerializer, long duration, ResponseDelegate responseDelegate) where TRequest : INetSerializable { if (!responseHandlers.ContainsKey(requestType)) { Logging.LogError($"Cannot create request. Request type: {requestType} not registered."); return(false); } if (!responseHandlers[requestType].IsRequestTypeValid(typeof(TRequest))) { Logging.LogError($"Cannot create request. Request type: {requestType}, {typeof(TRequest)} is not valid message type."); return(false); } // Create request uint ackId = CreateRequest(responseHandlers[requestType], duration, responseDelegate); // Write request writer.Reset(); writer.PutPackedUShort(RequestMessageType); writer.PutPackedUShort(requestType); writer.PutPackedUInt(ackId); request.Serialize(writer); if (extraRequestSerializer != null) { extraRequestSerializer.Invoke(writer); } return(true); }
public void SerializeAndDeserialize(SerializerDelegate serialize, DeserializerDelegate deserialize, Tuple <string, BinaryTreeSerializer.TreeNode> treeData) { Assert.AreEqual(treeData.Item1, serialize(treeData.Item2)); var d = deserialize(treeData.Item1); Assert.IsTrue(AreEqual(treeData.Item2, d)); }
/// <summary> /// Sets variant length serializer, smaller number takes less bytes than larger. /// </summary> public void SetSerializerVariant(bool usesNegativeValues = false) { if (usesNegativeValues) { Serializer = delegate(BitStream stream, ref long value) { stream.SerializeVariant(ref value); } } ; else { Serializer = delegate(BitStream stream, ref long value) { unchecked { if (stream.Reading) { value = stream.ReadInt64(); } else { stream.WriteInt64(value); } } } }; }
private static SerializeDelegate serialize(ScriptInfoSerializeHelper target, SerializerDelegate serializer) { return(obj => { var value = target.GetValue(obj) ?? target.defaultValue; return string.Format(FormatHelper.DefaultFormat, target.format, serializer(value)); }); }
public DeserializationPipeOptions( SerializerDelegate <T>?defaultDeserializer, IReadOnlyDictionary <string, SerializerDelegate <T> > deserializers ) { DefaultDeserializer = defaultDeserializer; Deserializers = deserializers; }
public bool SendRequest <TRequest>(ushort requestType, TRequest request, SerializerDelegate extraSerializer = null, long duration = 30, ResponseDelegate responseDelegate = null) where TRequest : INetSerializable { // Send request to server, so connection id will not being used if (!CreateAndWriteRequest(writer, requestType, request, extraSerializer, duration, responseDelegate)) { return(false); } SendMessage(-1, DeliveryMethod.ReliableOrdered, writer); return(true); }
public static void WritePacket( NetDataWriter writer, ushort messageType, SerializerDelegate extraSerializer) { WritePacket(writer, messageType); if (extraSerializer != null) { extraSerializer.Invoke(writer); } }
public static void RegisterSerializer(Type type, SerializerDelegate serializer, UInt64 hash) { #if OVERLOAD_LEVEL_EDITOR UInt64 currHash = CalculateHashForType(type); // If you hit this assert, it means that the type has changed since it the serialize code // was written for it. You need to update the serializer function and the hash. I put this // in here to catch if anyone subtley changes a type I serialize out. System.Diagnostics.Debug.Assert(currHash == hash, "Type has changed", "The type {0} has changed since its serializer was written - got {1} expected {2}", type.FullName, hash.ToString("X16"), currHash.ToString("X16")); #endif s_registeredTypes[type] = serializer; }
protected void WritePacket( NetDataWriter writer, ushort messageType, SerializerDelegate extraSerializer) { writer.Reset(); writer.PutPackedUShort(messageType); if (extraSerializer != null) { extraSerializer.Invoke(writer); } }
/// <summary> /// Serializes values as 0 or 1 /// </summary> public void SetSerializerBit() { Serializer = delegate(BitStream stream, ref long value) { if (stream.Reading) { value = stream.ReadBool() ? 1 : 0; } else { stream.WriteBool(value != 0); } }; }
public RabbitMqServiceOptionsBuilder WithSerializer(SerializerDelegate serializer, string?contentType) { if (contentType != null) { _serializers[contentType] = serializer; } if (_serializer == null) { _serializer = serializer; _contentType = contentType; } return(this); }
/// <summary> /// Sets optimal serizalizer for range of two values (with uniform probability) /// </summary> public void SetSerializerRange(int minInclusive, int maxInclusive) { uint valueCount = (uint)((long)maxInclusive - (long)minInclusive + 1); valueCount = MathHelper.GetNearestBiggerPowerOfTwo(valueCount); int bitCount = MathHelper.Log2(valueCount); Serializer = delegate(BitStream stream, ref long value) { if (stream.Reading) { value = (long)(stream.ReadUInt64()) + minInclusive; } else { stream.WriteUInt64((ulong)(value - minInclusive), bitCount); } }; }
public BaseStrategy(Type objectType) { _objectType = objectType; var buffer = Expression.Parameter(typeof(Span <byte>).MakeByRefType(), "buffer"); var deserContext = Expression.Parameter(typeof(DeserializationContext), "deserializationContext"); var objectForWork = Expression.Parameter(typeof(object), "obj"); var objWorkConverted = Expression.Parameter(objectType); var convert = Expression.Convert(objectForWork, objectType); _parameters.Add(objWorkConverted); var exp = new List <Expression> { Expression.Assign(objWorkConverted, convert) }; exp.AddRange(SetupObject(objectType, objWorkConverted, buffer, deserContext)); var finalBlock = Expression.Block(_parameters, exp); _serializer = Expression.Lambda <SerializerDelegate>(finalBlock, objectForWork, buffer, deserContext).Compile(); }
protected bool CreateAndWriteRequest <TRequest>( NetDataWriter writer, ushort requestType, TRequest request, ResponseDelegate <INetSerializable> responseDelegate, int millisecondsTimeout, SerializerDelegate extraRequestSerializer) where TRequest : INetSerializable, new() { if (!responseHandlers.ContainsKey(requestType)) { responseDelegate.Invoke(new ResponseHandlerData(nextRequestId++, this, -1, null), AckResponseCode.Unimplemented, EmptyMessage.Value); Logging.LogError($"Cannot create request. Request type: {requestType} not registered."); return(false); } if (!responseHandlers[requestType].IsRequestTypeValid(typeof(TRequest))) { responseDelegate.Invoke(new ResponseHandlerData(nextRequestId++, this, -1, null), AckResponseCode.Unimplemented, EmptyMessage.Value); Logging.LogError($"Cannot create request. Request type: {requestType}, {typeof(TRequest)} is not valid message type."); return(false); } // Create request uint requestId = CreateRequest(responseHandlers[requestType], responseDelegate, millisecondsTimeout); // Write request writer.Reset(); writer.PutPackedUShort(RequestMessageType); writer.PutPackedUShort(requestType); writer.PutPackedUInt(requestId); writer.Put(request); if (extraRequestSerializer != null) { extraRequestSerializer.Invoke(writer); } return(true); }
/// <summary> /// Sets default serializer which serializes always 8B /// </summary> public void SetSerializerDefault() { Serializer = delegate(BitStream stream, ref long value) { stream.Serialize(ref value); }; }
private void RequestProceeded(long connectionId, uint requestId, AckResponseCode responseCode, INetSerializable response, SerializerDelegate responseSerializer) { // Write response Writer.Reset(); Writer.PutPackedUShort(ResponseMessageType); Writer.PutPackedUInt(requestId); Writer.PutValue(responseCode); Writer.Put(response); if (responseSerializer != null) { responseSerializer.Invoke(Writer); } // Send response SendMessage(connectionId, 0, DeliveryMethod.ReliableUnordered, Writer); }
public void ClientSendPacket(DeliveryMethod options, ushort msgType, SerializerDelegate serializer) { Client.SendPacket(options, msgType, serializer); }
public ConsumerOptionsBuilder <T> WithDefaultDeSerializer(SerializerDelegate <T> deserializer) { _defaultDeserializer = deserializer; return(this); }
public bool ServerSendRequest <TRequest, TResponse>(long connectionId, ushort msgType, TRequest request, SerializerDelegate extraRequestSerializer = null, long duration = 30, ResponseDelegate <TResponse> responseDelegate = null) where TRequest : INetSerializable where TResponse : INetSerializable { return(Server.SendRequest(connectionId, msgType, request, extraRequestSerializer, duration, (requestHandler, responseCode, response) => { if (responseDelegate != null) { responseDelegate.Invoke(requestHandler, responseCode, (TResponse)response); } })); }
/// <summary> /// Configure the deserializer to use for a given ContentType. If a message's ContentType does not match /// any deserializer, it use the default one /// </summary> /// <param name="deserializer"></param> /// <param name="contentType"></param> /// <returns></returns> public ConsumerOptionsBuilder <T> WithDeSerializer(SerializerDelegate <T> deserializer, string contentType) { _deserializers[contentType] = deserializer; return(this); }
public void SendPacket(DeliveryMethod deliveryMethod, ushort msgType, SerializerDelegate serializer) { // Send packet to server, so connection id will not being used WritePacket(writer, msgType, serializer); SendMessage(-1, deliveryMethod, writer); }
public void ServerSendPacketToAllConnections(DeliveryMethod deliveryMethod, ushort msgType, SerializerDelegate serializer) { foreach (long connectionId in ConnectionIds) { ServerSendPacket(connectionId, deliveryMethod, msgType, serializer); } }
public void ClientSendPacket <T>(DeliveryMethod options, ushort msgType, T messageData, SerializerDelegate extraSerializer = null) where T : INetSerializable { ClientSendPacket(options, msgType, (writer) => { messageData.Serialize(writer); if (extraSerializer != null) { extraSerializer.Invoke(writer); } }); }
public bool ClientSendRequest <TRequest>(ushort requestType, TRequest request, SerializerDelegate extraRequestSerializer = null, long duration = 30, ResponseDelegate responseDelegate = null) where TRequest : INetSerializable { return(Client.SendRequest(requestType, request, extraRequestSerializer, duration, responseDelegate)); }
public void ServerSendPacket <T>(long connectionId, DeliveryMethod deliveryMethod, ushort msgType, T messageData, SerializerDelegate extraSerializer = null) where T : INetSerializable { ServerSendPacket(connectionId, deliveryMethod, msgType, (writer) => { messageData.Serialize(writer); if (extraSerializer != null) { extraSerializer.Invoke(writer); } }); }
public void ServerSendPacket(long connectionId, DeliveryMethod deliveryMethod, ushort msgType, SerializerDelegate serializer) { Server.SendPacket(connectionId, deliveryMethod, msgType, serializer); }
public bool ServerSendRequest <TRequest>(long connectionId, ushort msgType, TRequest request, SerializerDelegate extraRequestSerializer = null, long duration = 30, ResponseDelegate responseDelegate = null) where TRequest : INetSerializable { return(Server.SendRequest(connectionId, msgType, request, extraRequestSerializer, duration, responseDelegate)); }
public bool ClientSendRequest <TRequest, TResponse>(ushort requestType, TRequest request, SerializerDelegate extraRequestSerializer = null, long duration = 30, ResponseDelegate <TResponse> responseDelegate = null) where TRequest : INetSerializable where TResponse : INetSerializable { return(Client.SendRequest(requestType, request, extraRequestSerializer, duration, (requestHandler, responseCode, response) => { if (responseDelegate != null) { responseDelegate.Invoke(requestHandler, responseCode, (TResponse)response); } })); }