private object ReadBodyInternal(TLSerializationContext context, TLSerializationMode?itemsSerializationModeOverride = null)
{
Func <TLSerializationContext, TLSerializationMode?, object> read;
if (IsItemsTypeObject)
{
read = (sc, m) => TLRig.Deserialize <T>(sc, m);
}
else
{
ITLSerializer serializer = GetSerializer(context);
read = serializer.Read;
}
int length = context.Streamer.ReadInt32();
var list = (List <T>)Activator.CreateInstance(SupportedTypeInternal, length);
for (int i = 0; i < length; i++)
{
var item = (T)read(context, itemsSerializationModeOverride);
list.Add(item);
}
return(list);
}
private void WriteBodyInternal(object obj, TLSerializationContext context, TLSerializationMode?itemsSerializationModeOverride = null)
{
Action <object, TLSerializationContext, TLSerializationMode?> write;
if (IsItemsTypeObject)
{
write = TLRig.Serialize;
}
else
{
ITLSerializer serializer = GetSerializer(context);
write = serializer.Write;
}
var vector = obj as List <T>;
if (vector == null)
{
// TODO: log wrong type.
throw new InvalidOperationException("This serializer supports only List<> types.");
}
int length = vector.Count;
// Length.
context.Streamer.WriteInt32(length);
// Child objects.
for (int i = 0; i < length; i++)
{
write(vector[i], context, itemsSerializationModeOverride);
}
}
private TLSerializationMode?GetVectorItemsSerializationModeOverride(ITLVectorSerializer vectorSerializer, PropertyInfo propertyInfo,
TLSerializationContext context)
{
Type propType = propertyInfo.PropertyType;
if (vectorSerializer.SupportedType != propType)
{
throw new NotSupportedException(string.Format("Current vector serializer doesn't support type: {0}. It supports: {1}", propType,
vectorSerializer.SupportedType));
}
TLSerializationMode?itemsSerializationModeOverride = TLSerializationMode.Bare;
// Check for items serializer.
// If items have multiple constructors or have a TLTypeAttribute (in other words it is TL type),
// then items must be serialized as boxed.
Type itemsType = vectorSerializer.ItemsType;
ITLSerializer vectorItemSerializer = context.Rig.GetSerializerByObjectType(itemsType);
if (vectorItemSerializer is ITLMultiConstructorSerializer || itemsType.GetTypeInfo().GetCustomAttribute <TLTypeAttribute>() != null)
{
itemsSerializationModeOverride = TLSerializationMode.Boxed;
}
else
{
// Check for TLVector attribute with items serialization mode override.
var tlVectorAttribute = propertyInfo.GetCustomAttribute <TLVectorAttribute>();
if (tlVectorAttribute != null)
{
itemsSerializationModeOverride = tlVectorAttribute.ItemsModeOverride;
}
}
return(itemsSerializationModeOverride);
}
private void IndexType(uint constructorNumber, ITLSerializer serializer)
{
if (!_constructorNumberSerializersIndex.ContainsKey(constructorNumber))
{
_constructorNumberSerializersIndex.Add(constructorNumber, serializer);
}
}
/// <summary>
/// Deserialize an object from TL serialization context.
/// </summary>
/// <remarks>
/// Constructor number for the object is automatically determined by reading the first number from the streamer,
/// hence object within the context streamer must be serialized as boxed type.
/// </remarks>
/// <param name="context">TL serialization context.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="TLSerializerNotFoundException">When serializer not found.</exception>
public static object Deserialize(TLSerializationContext context)
{
// Here streamer's position must point to a boxed TL type.
TLStreamer streamer = context.Streamer;
// Read a constructor number and restore the streamer position.
streamer.PushPosition();
uint constructorNumber = streamer.ReadUInt32();
//Console.WriteLine("Retrived constructor number " + constructorNumber);
streamer.PopPosition();
ITLSerializer serializer = context.Rig.GetSerializerByConstructorNumber(constructorNumber);
//Console.WriteLine("Got serializer for above constructor number" + serializer.SupportedType);
if (serializer == null)
{
throw new TLSerializerNotFoundException(
string.Format("Constructor number: 0x{0:X8} is not supported by any registered serializer.", constructorNumber));
}
return(serializer.Read(context, TLSerializationMode.Boxed));
}
protected override object ReadBody(TLSerializationContext context)
{
object obj = Activator.CreateInstance(_objectType);
for (int i = 0; i < _properties.Length; i++)
{
TLPropertyInfo tlPropertyInfo = _properties[i];
PropertyInfo propertyInfo = tlPropertyInfo.PropertyInfo;
object propertyValue;
Type propType = propertyInfo.PropertyType;
ITLSerializer tlSerializer = context.Rig.GetSerializerByObjectType(propType);
if (tlSerializer is ITLVectorSerializer)
{
var vectorSerializer = tlSerializer as ITLVectorSerializer;
TLSerializationMode?itemsSerializationModeOverride = GetVectorItemsSerializationModeOverride(vectorSerializer, propertyInfo, context);
propertyValue = vectorSerializer.Read(context, tlPropertyInfo.SerializationModeOverride, itemsSerializationModeOverride);
}
else
{
propertyValue = tlSerializer.Read(context, tlPropertyInfo.SerializationModeOverride);
}
tlPropertyInfo.PropertyInfo.SetValue(obj, propertyValue);
}
return(obj);
}
private static ITLSerializer GetSerializer(TLSerializationContext context)
{
ITLSerializer serializer = context.Rig.GetSerializer <T>();
if (serializer == null)
{
throw new TLSerializerNotFoundException(string.Format("There is no serializer for a type: '{0}'.", ItemsTypeInternal.FullName));
}
return(serializer);
}
/// <summary>
/// Serialize an object.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="context">TL serialization context.</param>
/// <param name="modeOverride">Serialization mode override.</param>
/// <exception cref="TLSerializerNotFoundException">When serializer not found.</exception>
public static void Serialize(object obj, TLSerializationContext context, TLSerializationMode?modeOverride = null)
{
var objType = obj.GetType();
ITLSerializer serializer = context.Rig.GetSerializerByObjectType(objType);
if (serializer == null)
{
throw new TLSerializerNotFoundException(string.Format("There is no serializer for a type: '{0}'.", objType.FullName));
}
serializer.Write(obj, context, modeOverride);
}
/// <summary>
/// Deserialize an object from TL serialization context.
/// </summary>
/// <param name="objType">Type of the object.</param>
/// <param name="context">TL serialization context.</param>
/// <param name="modeOverride">Serialization mode override.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="TLSerializerNotFoundException">When serializer not found.</exception>
public static object Deserialize(Type objType, TLSerializationContext context, TLSerializationMode?modeOverride = null)
{
if (objType == typeof(object))
{
return(Deserialize(context));
}
ITLSerializer serializer = context.Rig.GetSerializerByObjectType(objType);
if (serializer == null)
{
throw new TLSerializerNotFoundException(string.Format("There is no serializer for a type: '{0}'.", objType.FullName));
}
return(serializer.Read(context, modeOverride));
}
/// <summary>
/// Deserialize an object from TL serialization context.
/// </summary>
/// <remarks>
/// Constructor number for the object is automatically determined by reading the first number from the streamer,
/// hence object within the context streamer must be serialized as boxed type.
/// </remarks>
/// <param name="context">TL serialization context.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="TLSerializerNotFoundException">When serializer not found.</exception>
public static object Deserialize(TLSerializationContext context)
{
TLStreamer streamer = context.Streamer;
// Read a constructor number.
uint constructorNumber = streamer.ReadUInt32();
ITLSerializer serializer = context.Rig.GetSerializerByConstructorNumber(constructorNumber);
if (serializer == null)
{
throw new TLSerializerNotFoundException(string.Format("Constructor number: 0x{0:X8} is not supported by any registered serializer.", constructorNumber));
}
// Bare because construction number has already been read.
return(serializer.Read(context, TLSerializationMode.Bare));
}
private static ITLPropertySerializationAgent[] CreateSerializationAgents(IEnumerable <TLPropertyInfo> tlPropertyInfos, TLSerializersBucket serializersBucket)
{
return(tlPropertyInfos.OrderBy(info => info.Order).Distinct().Select(
tlPropertyInfo =>
{
PropertyInfo propertyInfo = tlPropertyInfo.PropertyInfo;
Type propType = propertyInfo.PropertyType;
ITLPropertySerializationAgent serializationAgent;
if (propType == typeof(object))
{
/*
* https://core.telegram.org/mtproto/serialize#object-pseudotype
* Object Pseudotype
* The Object pseudotype is a “type” which can take on values that belong to any boxed type in the schema.
*/
serializationAgent = new TLObjectPropertySerializationAgent(tlPropertyInfo);
}
else
{
ITLSerializer tlSerializer = serializersBucket[propType];
Debug.Assert(tlSerializer != null);
var vectorSerializer = tlSerializer as ITLVectorSerializer;
if (vectorSerializer != null)
{
TLSerializationMode?itemsSerializationModeOverride = GetVectorItemsSerializationModeOverride(
vectorSerializer,
propertyInfo,
serializersBucket);
serializationAgent = new TLVectorPropertySerializationAgent(tlPropertyInfo, vectorSerializer, itemsSerializationModeOverride);
}
else
{
serializationAgent = new TLPropertySerializationAgent(tlPropertyInfo, tlSerializer);
}
}
return serializationAgent;
}).ToArray());
}
/// <summary>
/// Adds serializer.
/// </summary>
/// <param name="serializer">TL serializer.</param>
public void Add(ITLSerializer serializer)
{
Type type = serializer.SupportedType;
if (!_serializersIndex.ContainsKey(type))
{
_serializersIndex.Add(type, serializer);
var singleConstructorSerializer = serializer as ITLSingleConstructorSerializer;
if (singleConstructorSerializer != null)
{
IndexType(singleConstructorSerializer.ConstructorNumber, serializer);
}
var multipleConstructorSerializer = serializer as ITLMultiConstructorSerializer;
if (multipleConstructorSerializer != null)
{
foreach (uint constructorNumber in multipleConstructorSerializer.ConstructorNumbers)
{
IndexType(constructorNumber, serializer);
}
}
}
}
protected override void WriteBody(object obj, TLSerializationContext context)
{
for (int i = 0; i < _properties.Length; i++)
{
TLPropertyInfo tlPropertyInfo = _properties[i];
PropertyInfo propertyInfo = tlPropertyInfo.PropertyInfo;
Type propType = propertyInfo.PropertyType;
object propertyValue = propertyInfo.GetValue(obj);
ITLSerializer tlSerializer = context.Rig.GetSerializerByObjectType(propType);
if (tlSerializer is ITLVectorSerializer)
{
var vectorSerializer = tlSerializer as ITLVectorSerializer;
TLSerializationMode?itemsSerializationModeOverride = GetVectorItemsSerializationModeOverride(vectorSerializer, propertyInfo, context);
vectorSerializer.Write(propertyValue, context, tlPropertyInfo.SerializationModeOverride, itemsSerializationModeOverride);
}
else
{
tlSerializer.Write(propertyValue, context, tlPropertyInfo.SerializationModeOverride);
}
}
}
public TLPropertySerializationAgent(TLPropertyInfo tlPropertyInfo, ITLSerializer serializer) : base(tlPropertyInfo)
{
_serializer = serializer;
}
public TLPropertySerializationAgent(TLPropertyInfo tlPropertyInfo, ITLSerializer serializer)
: base(tlPropertyInfo)
{
_serializer = serializer;
}