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