public ReflectionNonGenericDictionaryMessagePackSerializer(
SerializationContext ownerContext,
Type targetType,
CollectionTraits collectionTraits,
PolymorphismSchema itemsSchema,
SerializationTarget targetInfo
)
: base(ownerContext, itemsSchema, targetInfo.GetCapabilitiesForCollection(collectionTraits))
{
if (targetInfo.CanDeserialize)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory <TDictionary, object>(targetInfo.DeserializationConstructor);
}
else
{
this._factory = _ => { throw SerializationExceptions.NewCreateInstanceIsNotSupported(targetType); };
}
this._isPackable = typeof(IPackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
#if FEATURE_TAP
this._isAsyncPackable = typeof(IAsyncPackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
this._isAsyncUnpackable = typeof(IAsyncUnpackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
#endif // FEATURE_TAP
}
public ReflectionObjectMessagePackSerializer(SerializationContext context, SerializationTarget target, SerializerCapabilities capabilities)
: base(context, capabilities)
{
ReflectionSerializerHelper.GetMetadata(typeof(T), target.Members, context, out this._getters, out this._setters, out this._memberInfos, out this._contracts, out this._serializers);
this._memberIndexes =
this._contracts
.Select((contract, index) => new KeyValuePair <string, int>(contract.Name, index))
.Where(kv => kv.Key != null)
// Set key as transformed.
.ToDictionary(kv => context.DictionarySerlaizationOptions.SafeKeyTransformer(kv.Key), kv => kv.Value);
this._constructorParameters =
(!typeof(IUnpackable).IsAssignableFrom(typeof(T)) && target.IsConstructorDeserialization)
? target.DeserializationConstructor.GetParameters()
: null;
if (this._constructorParameters != null)
{
this._constructorArgumentIndexes = new Dictionary <int, int>(this._memberIndexes.Count);
foreach (var member in target.Members)
{
int index =
#if SILVERLIGHT && !WINDOWS_PHONE
this._constructorParameters.FindIndex(
#else
Array.FindIndex(this._constructorParameters,
#endif // SILVERLIGHT && !WINDOWS_PHONE
item => item.Name.Equals(member.Contract.Name, StringComparison.OrdinalIgnoreCase) && item.ParameterType == member.Member.GetMemberValueType()
);
if (index >= 0)
{
this._constructorArgumentIndexes.Add(index, this._memberIndexes[member.Contract.Name]);
}
}
}
}
public ReflectionCollectionMessagePackSerializer(
SerializationContext ownerContext,
Type targetType,
PolymorphismSchema itemsSchema)
: base(ownerContext, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory <TCollection, TItem>(targetType);
}
public ReflectionNonGenericDictionaryMessagePackSerializer(
SerializationContext ownerContext,
Type abstractType,
Type concreteType,
PolymorphismSchema itemsSchema
)
: base(ownerContext, abstractType, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory(abstractType, concreteType, typeof(object));
}
public ReflectionObjectMessagePackSerializer(SerializationContext context)
: base(context)
{
ReflectionSerializerHelper.GetMetadata(context, typeof(T), out this._getters, out this._setters, out this._memberInfos, out this._contracts, out this._serializers);
this._memberIndexes =
this._contracts
.Select((contract, index) => new KeyValuePair <string, int>(contract.Name, index))
.Where(kv => kv.Key != null)
.ToDictionary(kv => kv.Key, kv => kv.Value);
}
public ReflectionCollectionMessagePackSerializer(
SerializationContext ownerContext,
Type abstractType,
Type concreteType,
CollectionTraits traits,
PolymorphismSchema itemsSchema)
: base(ownerContext, abstractType, traits, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory(abstractType, concreteType, traits.ElementType);
}
public ReflectionNonGenericEnumerableMessagePackSerializer(
SerializationContext ownerContext,
Type targetType,
PolymorphismSchema itemsSchema
)
: base(ownerContext, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory <TCollection, object>(targetType);
this._addItem = ReflectionSerializerHelper.GetAddItem <TCollection, object>(targetType);
}
public ReflectionNonGenericListMessagePackSerializer(
SerializationContext ownerContext,
Type abstractType,
Type concreteType,
PolymorphismSchema itemsSchema
)
: base(ownerContext, abstractType, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory(abstractType, concreteType, typeof(object));
this._isPackable = typeof(IPackable).IsAssignableFrom(concreteType ?? abstractType);
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(concreteType ?? abstractType);
}
public ReflectionEnumerableMessagePackSerializer(
SerializationContext ownerContext,
Type abstractType,
Type concreteType,
CollectionTraits traits,
PolymorphismSchema itemsSchema
)
: base(ownerContext, abstractType, traits, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory(abstractType, concreteType, traits.ElementType);
this._addItem = ReflectionSerializerHelper.GetAddItem(concreteType, traits);
this._isPackable = typeof(IPackable).IsAssignableFrom(concreteType ?? abstractType);
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(concreteType ?? abstractType);
}
public ReflectionDictionaryMessagePackSerializer(
SerializationContext ownerContext,
Type abstractType,
Type concreteType,
Type keyType,
Type valueType,
CollectionTraits traits,
PolymorphismSchema itemsSchema
)
: base(ownerContext, abstractType, keyType, valueType, traits, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory(abstractType, concreteType, keyType);
this._isPackable = typeof(IPackable).IsAssignableFrom(concreteType ?? abstractType);
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(concreteType ?? abstractType);
}
public ReflectionDictionaryMessagePackSerializer(
SerializationContext ownerContext,
Type targetType,
PolymorphismSchema itemsSchema
)
: base(ownerContext, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory <TDictionary, TKey>(targetType);
this._isPackable = typeof(IPackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
#if FEATURE_TAP
this._isAsyncPackable = typeof(IAsyncPackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
this._isAsyncUnpackable = typeof(IAsyncUnpackable).IsAssignableFrom(targetType ?? typeof(TDictionary));
#endif // FEATURE_TAP
}
public ReflectionEnumerableMessagePackSerializer(
SerializationContext ownerContext,
Type targetType,
CollectionTraits collectionTraits,
PolymorphismSchema itemsSchema
)
: base(ownerContext, itemsSchema)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory <TCollection, TItem>(targetType);
this._addItem = ReflectionSerializerHelper.GetAddItem <TCollection, TItem>(targetType, collectionTraits);
this._isPackable = typeof(IPackable).IsAssignableFrom(targetType ?? typeof(TCollection));
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(targetType ?? typeof(TCollection));
#if FEATURE_TAP
this._isAsyncPackable = typeof(IAsyncPackable).IsAssignableFrom(targetType ?? typeof(TCollection));
this._isAsyncUnpackable = typeof(IAsyncUnpackable).IsAssignableFrom(targetType ?? typeof(TCollection));
#endif // FEATURE_TAP
}
public ReflectionNonGenericDictionaryMessagePackSerializer(
SerializationContext ownerContext,
Type abstractType,
Type concreteType,
CollectionTraits concreteTypeCollectionTraits,
PolymorphismSchema itemsSchema,
SerializationTarget targetInfo
)
: base(ownerContext, abstractType, itemsSchema, targetInfo.GetCapabilitiesForCollection(concreteTypeCollectionTraits))
{
if (targetInfo.CanDeserialize)
{
this._factory = ReflectionSerializerHelper.CreateCollectionInstanceFactory(abstractType, concreteType, typeof(object), targetInfo.DeserializationConstructor);
}
else
{
this._factory = _ => { throw SerializationExceptions.NewCreateInstanceIsNotSupported(concreteType); };
}
this._isPackable = typeof(IPackable).IsAssignableFrom(concreteType ?? abstractType);
this._isUnpackable = typeof(IUnpackable).IsAssignableFrom(concreteType ?? abstractType);
}
