private static void EmitDeserializeValueCore(SerializerEmitter emitter, TracingILGenerator il, int unpackerArgumentIndex, LocalBuilder value, Type targetType, SerializingMember?member, string memberName, Label endOfDeserialization, LocalVariableHolder localHolder)
{
MethodInfo directReadMethod = _Unpacker.GetDirectReadMethod(value.LocalType);
if ((directReadMethod != null) && (!member.HasValue || !UnpackHelpers.IsReadOnlyAppendableCollectionMember(member.Value.Member)))
{
LocalBuilder isDeserializationSucceeded = localHolder.IsDeserializationSucceeded;
il.EmitLdc_I4_0();
il.EmitAnyStloc(isDeserializationSucceeded);
il.BeginExceptionBlock();
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitAnyLdloca(value);
il.EmitAnyCall(directReadMethod);
il.EmitAnyStloc(isDeserializationSucceeded);
il.BeginCatchBlock(typeof(MessageTypeException));
LocalBuilder catchedException = localHolder.GetCatchedException(typeof(MessageTypeException));
il.EmitAnyStloc(catchedException);
il.EmitTypeOf(targetType);
il.EmitLdstr(memberName);
il.EmitAnyLdloc(catchedException);
il.EmitAnyCall(SerializationExceptions.NewFailedToDeserializeMemberMethod);
il.EmitThrow();
il.EndExceptionBlock();
Label target = il.DefineLabel("END_IF");
il.EmitAnyLdloc(isDeserializationSucceeded);
il.EmitBrtrue_S(target);
il.EmitAnyCall(SerializationExceptions.NewUnexpectedEndOfStreamMethod);
il.EmitThrow();
il.MarkLabel(target);
if (member.HasValue)
{
EmitNilImplicationForPrimitive(il, member.Value, value, endOfDeserialization);
}
}
else
{
EmitGeneralRead(il, unpackerArgumentIndex);
if (member.HasValue)
{
EmitNilImplication(il, unpackerArgumentIndex, member.Value.Contract.Name, member.Value.Contract.NilImplication, endOfDeserialization, localHolder);
}
Label label2 = il.DefineLabel("THEN_IF_COLLECTION");
Label label3 = il.DefineLabel("END_IF_COLLECTION");
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.IsArrayHeader);
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.IsMapHeader);
il.EmitOr();
il.EmitBrtrue_S(label2);
EmitUnpackFrom(emitter, il, value, unpackerArgumentIndex);
il.EmitBr_S(label3);
LocalBuilder subtreeUnpacker = localHolder.SubtreeUnpacker;
il.MarkLabel(label2);
EmitUnpackerBeginReadSubtree(il, unpackerArgumentIndex, subtreeUnpacker);
EmitUnpackFrom(emitter, il, value, subtreeUnpacker);
EmitUnpackerEndReadSubtree(il, subtreeUnpacker);
il.MarkLabel(label3);
}
}
private static void EmitUnpackMembersFromMap(SerializerEmitter emitter, TracingILGenerator unpackerIL, SerializingMember[] entries, LocalBuilder result, LocalVariableHolder localHolder)
{
Label label = unpackerIL.DefineLabel("BEGIN_LOOP");
Label target = unpackerIL.DefineLabel("END_LOOP");
unpackerIL.MarkLabel(label);
LocalBuilder memberName = localHolder.MemberName;
unpackerIL.EmitAnyLdarg(1);
unpackerIL.EmitAnyLdloca(memberName);
unpackerIL.EmitAnyCall(_Unpacker.ReadString);
unpackerIL.EmitBrfalse(target);
LocalBuilder unpackedData = localHolder.UnpackedData;
LocalBuilder unpackedDataValue = localHolder.UnpackedDataValue;
for (int i = 0; i < entries.Length; i++)
{
if (entries[i].Contract.Name != null)
{
unpackerIL.EmitAnyLdloc(memberName);
unpackerIL.EmitLdstr(entries[i].Contract.Name);
unpackerIL.EmitAnyCall(_String.op_Equality);
Label label3 = unpackerIL.DefineLabel("END_IF_MEMBER_" + i);
unpackerIL.EmitBrfalse(label3);
if (entries[i].Member == null)
{
Emittion.EmitGeneralRead(unpackerIL, 1);
}
else if (UnpackHelpers.IsReadOnlyAppendableCollectionMember(entries[i].Member))
{
Emittion.EmitDeserializeCollectionValue(emitter, unpackerIL, 1, result, entries[i].Member, entries[i].Member.GetMemberValueType(), entries[i].Contract.NilImplication, localHolder);
}
else
{
Emittion.EmitDeserializeValue(emitter, unpackerIL, 1, result, entries[i], localHolder);
}
unpackerIL.EmitBr(label);
unpackerIL.MarkLabel(label3);
}
}
unpackerIL.EmitAnyLdarg(1);
unpackerIL.EmitCallvirt(_Unpacker.Read);
unpackerIL.EmitPop();
unpackerIL.EmitBr(label);
unpackerIL.MarkLabel(target);
}
private static void EmitUnpackMembersFromArray(SerializerEmitter emitter, TracingILGenerator unpackerIL, SerializingMember[] entries, LocalBuilder result, LocalVariableHolder localHolder)
{
LocalBuilder itemsCount = localHolder.ItemsCount;
LocalBuilder local = unpackerIL.DeclareLocal(typeof(int), "unpacked");
Emittion.EmitGetUnpackerItemsCountAsInt32(unpackerIL, 1, localHolder);
unpackerIL.EmitAnyStloc(itemsCount);
for (int i = 0; i < entries.Length; i++)
{
Label endOfDeserialization = unpackerIL.DefineLabel("END_IF");
Label target = unpackerIL.DefineLabel("ELSE");
unpackerIL.EmitAnyLdloc(local);
unpackerIL.EmitAnyLdloc(itemsCount);
unpackerIL.EmitBlt(target);
if (entries[i].Member != null)
{
Emittion.EmitNilImplication(unpackerIL, 1, entries[i].Contract.Name, entries[i].Contract.NilImplication, endOfDeserialization, localHolder);
}
unpackerIL.EmitBr(endOfDeserialization);
unpackerIL.MarkLabel(target);
if (entries[i].Member == null)
{
Emittion.EmitGeneralRead(unpackerIL, 1);
}
else if (UnpackHelpers.IsReadOnlyAppendableCollectionMember(entries[i].Member))
{
Emittion.EmitDeserializeCollectionValue(emitter, unpackerIL, 1, result, entries[i].Member, entries[i].Member.GetMemberValueType(), entries[i].Contract.NilImplication, localHolder);
}
else
{
Emittion.EmitDeserializeValue(emitter, unpackerIL, 1, result, entries[i], localHolder);
}
unpackerIL.EmitAnyLdloc(local);
unpackerIL.EmitLdc_I4_1();
unpackerIL.EmitAdd();
unpackerIL.EmitAnyStloc(local);
unpackerIL.MarkLabel(endOfDeserialization);
}
}
/// <summary>
/// Emits the deserialize value.
/// </summary>
/// <param name="emitter">The emitter.</param>
/// <param name="il">The il generator.</param>
/// <param name="unpackerArgumentIndex">Index of the unpacker argument.</param>
/// <param name="value">The value local variable which stores unpacked value.</param>
/// <param name="targetType">The type of deserialzing type.</param>
/// <param name="member">The metadata for nil implication. Specify <c>null</c> if nil implication is not needed.</param>
/// <param name="memberName">The name of the member.</param>
/// <param name="endOfDeserialization">The end of deserialization label for nil implication.</param>
/// <param name="localHolder">The <see cref="LocalVariableHolder"/> which holds shared local variable information.</param>
private static void EmitDeserializeValueCore(SerializerEmitter emitter, TracingILGenerator il, int unpackerArgumentIndex, LocalBuilder value, Type targetType, SerializingMember?member, string memberName, Label endOfDeserialization, LocalVariableHolder localHolder)
{
var directUnpacking = Metadata._Unpacker.GetDirectReadMethod(value.LocalType);
if (directUnpacking != null && (member == null || !UnpackHelpers.IsReadOnlyAppendableCollectionMember(member.Value.Member)))
{
var isSuccess = localHolder.IsDeserializationSucceeded;
il.EmitLdc_I4_0();
il.EmitAnyStloc(isSuccess);
il.BeginExceptionBlock();
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitAnyLdloca(value);
il.EmitAnyCall(directUnpacking);
il.EmitAnyStloc(isSuccess);
il.BeginCatchBlock(typeof(MessageTypeException));
var ex = localHolder.GetCatchedException(typeof(MessageTypeException));
il.EmitAnyStloc(ex);
il.EmitTypeOf(targetType);
il.EmitLdstr(memberName);
il.EmitAnyLdloc(ex);
il.EmitAnyCall(SerializationExceptions.NewFailedToDeserializeMemberMethod);
il.EmitThrow();
il.EndExceptionBlock();
var endIf0 = il.DefineLabel("END_IF");
il.EmitAnyLdloc(isSuccess);
il.EmitBrtrue_S(endIf0);
il.EmitAnyCall(SerializationExceptions.NewUnexpectedEndOfStreamMethod);
il.EmitThrow();
il.MarkLabel(endIf0);
if (member != null)
{
// If null, nil implication is NOT needed.
EmitNilImplicationForPrimitive(il, member.Value, value, endOfDeserialization);
}
}
else
{
EmitGeneralRead(il, unpackerArgumentIndex);
if (member != null)
{
// If null, nil implication is NOT needed.
EmitNilImplication(
il,
unpackerArgumentIndex,
member.Value.Contract.Name,
member.Value.Contract.NilImplication,
endOfDeserialization,
localHolder
);
}
var thenIffCollection = il.DefineLabel("THEN_IF_COLLECTION");
var endIfCollection = il.DefineLabel("END_IF_COLLECTION");
/*
* if( !unpacker.IsArrayHeader && !unpacker.IsMapHeader )
* {
* value = GET_SERIALIZER().UnpackFrom( unpacker );
* }
* else
* {
* using( var subtreeUnpacker = unpacker.ReadSubtree() )
* {
* value = GET_SERIALIZER().UnpackFrom( subtreeUnpacker );
* }
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.IsArrayHeader);
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.IsMapHeader);
il.EmitOr();
il.EmitBrtrue_S(thenIffCollection);
EmitUnpackFrom(emitter, il, value, unpackerArgumentIndex);
il.EmitBr_S(endIfCollection);
var subtreeUnpacker = localHolder.SubtreeUnpacker;
il.MarkLabel(thenIffCollection);
EmitUnpackerBeginReadSubtree(il, unpackerArgumentIndex, subtreeUnpacker);
EmitUnpackFrom(emitter, il, value, subtreeUnpacker);
EmitUnpackerEndReadSubtree(il, subtreeUnpacker);
il.MarkLabel(endIfCollection);
}
}
private static void EmitUnpackMembersFromMap(SerializerEmitter emitter, TracingILGenerator unpackerIL, SerializingMember[] entries, LocalBuilder result, LocalVariableHolder localHolder)
{
/*
* var memberName = unpacker.Data.AsString();
* if( memberName == "A" )
* {
* if( !unpacker.Read() )
* {
* throw SerializationExceptions.NewUnexpectedStreamEndsException();
* }
*
* isAFound = true;
* }
* :
*/
var beginLoop = unpackerIL.DefineLabel("BEGIN_LOOP");
var endLoop = unpackerIL.DefineLabel("END_LOOP");
unpackerIL.MarkLabel(beginLoop);
var memberName = localHolder.MemberName;
unpackerIL.EmitAnyLdarg(1);
unpackerIL.EmitAnyLdloca(memberName);
unpackerIL.EmitAnyCall(Metadata._Unpacker.ReadString);
unpackerIL.EmitBrfalse(endLoop);
for (int i = 0; i < entries.Length; i++)
{
if (entries[i].Contract.Name == null)
{
// skip undefined member
continue;
}
// TODO: binary comparison
// Is it current member?
unpackerIL.EmitAnyLdloc(memberName);
unpackerIL.EmitLdstr(entries[i].Contract.Name);
unpackerIL.EmitAnyCall(Metadata._String.op_Equality);
var endIfCurrentMember = unpackerIL.DefineLabel("END_IF_MEMBER_" + i);
unpackerIL.EmitBrfalse(endIfCurrentMember);
// Deserialize value
if (entries[i].Member == null)
{
Emittion.EmitGeneralRead(unpackerIL, 1);
// Ignore undefined member -- Nop.
}
else if (UnpackHelpers.IsReadOnlyAppendableCollectionMember(entries[i].Member))
{
Emittion.EmitDeserializeCollectionValue(
emitter,
unpackerIL,
1,
result,
entries[i].Member,
entries[i].Member.GetMemberValueType(),
entries[i].Contract.NilImplication,
localHolder
);
}
else
{
Emittion.EmitDeserializeValue(
emitter,
unpackerIL,
1,
result,
entries[i],
localHolder
);
}
// TOOD: Record for missing check
unpackerIL.EmitBr(beginLoop);
unpackerIL.MarkLabel(endIfCurrentMember);
}
// Drain next value with unpacker.Read()
unpackerIL.EmitAnyLdarg(1);
unpackerIL.EmitCallvirt(Metadata._Unpacker.Read);
unpackerIL.EmitPop();
unpackerIL.EmitBr(beginLoop);
unpackerIL.MarkLabel(endLoop);
}
private static void EmitUnpackMembersFromArray(SerializerEmitter emitter, TracingILGenerator unpackerIL, SerializingMember[] entries, LocalBuilder result, LocalVariableHolder localHolder, Label endOfDeserialization)
{
/*
* int unpacked = 0;
* int itemsCount = unpacker.ItemsCount;
*
* :
* if( unpacked >= itemsCount )
* {
* HandleNilImplication(...);
* }
* else
* {
* #if PRIMITIVE
* if( !unpacker.ReadT( out local1 ) )
* {
* throw SerializationExceptions.NewUnexpectedEndOfStreamMethod();
* }
* #else
* if( !unpacker.Read() )
* {
* throw SerializationExceptions.NewUnexpectedEndOfStreamMethod();
* }
*
* local1 = this._serializer1.Unpack
* #endif
* unpacked++;
* }
* :
*/
// TODO: Supports ExtensionObject like round-tripping.
var itemsCount = localHolder.ItemsCount;
var unpacked = unpackerIL.DeclareLocal(typeof(int), "unpacked");
Emittion.EmitGetUnpackerItemsCountAsInt32(unpackerIL, 1, localHolder);
unpackerIL.EmitAnyStloc(itemsCount);
for (int i = 0; i < entries.Length; i++)
{
var endIf0 = unpackerIL.DefineLabel("END_IF");
var else0 = unpackerIL.DefineLabel("ELSE");
unpackerIL.EmitAnyLdloc(unpacked);
unpackerIL.EmitAnyLdloc(itemsCount);
unpackerIL.EmitBge(else0);
if (entries[i].Member == null)
{
Emittion.EmitGeneralRead(unpackerIL, 1);
// Ignore undefined member -- Nop.
}
else if (UnpackHelpers.IsReadOnlyAppendableCollectionMember(entries[i].Member))
{
Emittion.EmitDeserializeCollectionValue(
emitter,
unpackerIL,
1,
result,
entries[i].Member,
entries[i].Member.GetMemberValueType(),
entries[i].Contract.NilImplication,
localHolder
);
}
else
{
Emittion.EmitDeserializeValue(
emitter,
unpackerIL,
1,
result,
entries[i],
localHolder
);
}
unpackerIL.EmitAnyLdloc(unpacked);
unpackerIL.EmitLdc_I4_1();
unpackerIL.EmitAdd();
unpackerIL.EmitAnyStloc(unpacked);
unpackerIL.EmitBr(endIf0);
unpackerIL.MarkLabel(else0);
if (entries[i].Member != null)
{
// Respect nil implication.
switch (entries[i].Contract.NilImplication)
{
case NilImplication.MemberDefault:
{
unpackerIL.EmitBr(endOfDeserialization);
break;
}
case NilImplication.Null:
{
if (entries[i].Member.GetMemberValueType().GetIsValueType())
{
if (Nullable.GetUnderlyingType(entries[i].Member.GetMemberValueType()) == null)
{
// val type
/*
* if( value == null )
* {
* throw SerializationEceptions.NewValueTypeCannotBeNull( "...", typeof( MEMBER ), typeof( TYPE ) );
* }
*/
unpackerIL.EmitLdstr(entries[i].Contract.Name);
unpackerIL.EmitLdtoken(entries[i].Member.GetMemberValueType());
unpackerIL.EmitAnyCall(Metadata._Type.GetTypeFromHandle);
unpackerIL.EmitLdtoken(entries[i].Member.DeclaringType);
unpackerIL.EmitAnyCall(Metadata._Type.GetTypeFromHandle);
unpackerIL.EmitAnyCall(SerializationExceptions.NewValueTypeCannotBeNull3Method);
unpackerIL.EmitThrow();
}
else
{
// nullable
unpackerIL.EmitAnyLdloca(localHolder.GetDeserializedValue(entries[i].Member.GetMemberValueType()));
unpackerIL.EmitInitobj(entries[i].Member.GetMemberValueType());
unpackerIL.EmitAnyLdloc(result);
unpackerIL.EmitAnyLdloc(localHolder.GetDeserializedValue(entries[i].Member.GetMemberValueType()));
Emittion.EmitStoreValue(unpackerIL, entries[i].Member);
}
}
else
{
// ref type
unpackerIL.EmitAnyLdloc(result);
unpackerIL.EmitLdnull();
Emittion.EmitStoreValue(unpackerIL, entries[i].Member);
}
break;
}
case NilImplication.Prohibit:
{
unpackerIL.EmitLdstr(entries[i].Contract.Name);
unpackerIL.EmitAnyCall(SerializationExceptions.NewNullIsProhibitedMethod);
unpackerIL.EmitThrow();
break;
}
}
}
unpackerIL.MarkLabel(endIf0);
}
}
protected ObjectReflectionMessagePackSerializer(Type type, SerializationContext context, SerializingMember[] members)
: base(type, (context ?? SerializationContext.Default).CompatibilityOptions.PackerCompatibilityOptions)
{
if (type.GetIsAbstract() || type.GetIsInterface())
{
throw SerializationExceptions.NewNotSupportedBecauseCannotInstanciateAbstractType(type);
}
this._createInstance = () => Activator.CreateInstance(type);
//Expression.Lambda<Func<T>>(
// typeof(T).GetIsValueType()
// ? Expression.Default(typeof(T)) as Expression
// : Expression.New(typeof(T).GetConstructor(ReflectionAbstractions.EmptyTypes))
// ).Compile();
var isPackable = typeof(IPackable).IsAssignableFrom(type);
var isUnpackable = typeof(IUnpackable).IsAssignableFrom(type);
if (isPackable && isUnpackable)
{
this._memberSerializers = null;
this._indexMap = null;
this._isCollection = null;
this._nilImplications = null;
this._memberNames = null;
}
else
{
this._memberSerializers =
members.Select(
m => m.Member == null ? NullSerializer.Instance : context.GetSerializer(m.Member.GetMemberValueType())).ToArray
(
);
this._indexMap =
members
.Select((m, i) => new KeyValuePair <SerializingMember, int>(m, i))
.Where(kv => kv.Key.Member != null)
.ToDictionary(kv => kv.Key.Contract.Name, kv => kv.Value);
this._isCollection =
members.Select(
m => m.Member == null ? CollectionTraits.NotCollection : m.Member.GetMemberValueType().GetCollectionTraits()).
Select(t => t.CollectionType != CollectionKind.NotCollection).ToArray();
// NilImplication validity check
foreach (var member in members)
{
switch (member.Contract.NilImplication)
{
case NilImplication.Null:
{
if (member.Member.GetMemberValueType().GetIsValueType() &&
Nullable.GetUnderlyingType(member.Member.GetMemberValueType()) == null)
{
throw SerializationExceptions.NewValueTypeCannotBeNull(
member.Contract.Name, member.Member.GetMemberValueType(), member.Member.DeclaringType
);
}
if (!member.Member.CanSetValue())
{
throw SerializationExceptions.NewReadOnlyMemberItemsMustNotBeNull(member.Contract.Name);
}
break;
}
}
}
this._nilImplications = members.Select(m => m.Contract.NilImplication).ToArray();
this._memberNames = members.Select(m => m.Contract.Name).ToArray();
}
if (isPackable)
{
this._packToMessage = (target, packer, packingOptions) =>
{
((IPackable)target).PackToMessage(packer, packingOptions);
//typeof(T).GetInterfaceMap(typeof(IPackable)).TargetMethods.Single().Invoke(target, new object[] { packer, packingOptions });
};
this._memberGetters = null;
}
else
{
this._packToMessage = null;
this._memberGetters =
members.Select <SerializingMember, Func <object, object> >(
m => m.Member == null ? (target => null)
: CreateMemberGetter(m)).ToArray();
}
if (isUnpackable)
{
this._unpackFromMessage = delegate(ref object target, Unpacker value)
{
((IUnpackable)target).UnpackFromMessage(value);
};
this._memberSetters = null;
}
else
{
this._unpackFromMessage = null;
this._memberSetters =
members.Select(
m =>
m.Member == null
? delegate(ref object target, object memberValue) { }
:
m.Member.CanSetValue()
? CreateMemberSetter(m)
: UnpackHelpers.IsReadOnlyAppendableCollectionMember(m.Member)
? default(MemberSetter)
: ThrowGetOnlyMemberIsInvalid(m.Member)
).ToArray();
}
}
protected ObjectExpressionMessagePackSerializer(SerializationContext context, SerializingMember[] members)
: base((context ?? SerializationContext.Default).CompatibilityOptions.PackerCompatibilityOptions)
{
if (typeof(T).GetIsAbstract() || typeof(T).GetIsInterface())
{
throw SerializationExceptions.NewNotSupportedBecauseCannotInstanciateAbstractType(typeof(T));
}
this._createInstance =
Expression.Lambda <Func <T> >(
typeof(T).GetIsValueType()
? Expression.Default(typeof(T)) as Expression
: Expression.New(typeof(T).GetConstructor(ReflectionAbstractions.EmptyTypes))
).Compile();
var isPackable = typeof(IPackable).IsAssignableFrom(typeof(T));
var isUnpackable = typeof(IUnpackable).IsAssignableFrom(typeof(T));
var targetParameter = Expression.Parameter(typeof(T), "target");
if (isPackable && isUnpackable)
{
this._memberSerializers = null;
this._indexMap = null;
this._isCollection = null;
this._nilImplications = null;
this._memberNames = null;
}
else
{
this._memberSerializers =
members.Select(
m => m.Member == null ? NullSerializer.Instance : context.GetSerializer(m.Member.GetMemberValueType())).ToArray
(
);
this._indexMap =
members
.Zip(Enumerable.Range(0, members.Length), (m, i) => new KeyValuePair <SerializingMember, int>(m, i))
.Where(kv => kv.Key.Member != null)
.ToDictionary(kv => kv.Key.Contract.Name, kv => kv.Value);
this._isCollection =
members.Select(
m => m.Member == null ? CollectionTraits.NotCollection : m.Member.GetMemberValueType().GetCollectionTraits()).
Select(t => t.CollectionType != CollectionKind.NotCollection).ToArray();
// NilImplication validity check
foreach (var member in members)
{
switch (member.Contract.NilImplication)
{
case NilImplication.Null:
{
if (member.Member.GetMemberValueType().GetIsValueType() &&
Nullable.GetUnderlyingType(member.Member.GetMemberValueType()) == null)
{
throw SerializationExceptions.NewValueTypeCannotBeNull(
member.Contract.Name, member.Member.GetMemberValueType(), member.Member.DeclaringType
);
}
if (!member.Member.CanSetValue())
{
throw SerializationExceptions.NewReadOnlyMemberItemsMustNotBeNull(member.Contract.Name);
}
break;
}
}
}
this._nilImplications = members.Select(m => m.Contract.NilImplication).ToArray();
this._memberNames = members.Select(m => m.Contract.Name).ToArray();
}
if (isPackable)
{
var packerParameter = Expression.Parameter(typeof(Packer), "packer");
var optionsParameter = Expression.Parameter(typeof(PackingOptions), "options");
this._packToMessage =
Expression.Lambda <Action <T, Packer, PackingOptions> >(
Expression.Call(
targetParameter,
typeof(T).GetInterfaceMap(typeof(IPackable)).TargetMethods.Single(),
packerParameter,
optionsParameter
),
targetParameter, packerParameter, optionsParameter
).Compile();
this._memberGetters = null;
}
else
{
this._packToMessage = null;
this._memberGetters =
members.Select(
m =>
m.Member == null
? Expression.Lambda <Func <T, object> >(
Expression.Constant(null),
targetParameter
).Compile()
: CreateMemberGetter(targetParameter, m)
).ToArray();
}
var refTargetParameter = Expression.Parameter(typeof(T).MakeByRefType(), "target");
if (isUnpackable)
{
var unpackerParameter = Expression.Parameter(typeof(Unpacker), "unpacker");
this._unpackFromMessage =
Expression.Lambda <UnpackFromMessageInvocation>(
Expression.Call(
refTargetParameter,
typeof(T).GetInterfaceMap(typeof(IUnpackable)).TargetMethods.Single(),
unpackerParameter
),
refTargetParameter, unpackerParameter
).Compile();
this._memberSetters = null;
}
else
{
this._unpackFromMessage = null;
var valueParameter = Expression.Parameter(typeof(object), "value");
this._memberSetters =
members.Select(
m =>
m.Member == null
? Expression.Lambda <MemberSetter>(
Expression.Empty(),
refTargetParameter,
valueParameter
).Compile()
: m.Member.CanSetValue()
? Expression.Lambda <MemberSetter>(
Expression.Assign(
Expression.PropertyOrField(
refTargetParameter,
m.Member.Name
),
Expression.Call(
Metadata._UnpackHelpers.ConvertWithEnsuringNotNull_1Method.MakeGenericMethod(m.Member.GetMemberValueType()),
valueParameter,
Expression.Constant(m.Member.Name),
Expression.Call( // Using RuntimeTypeHandle to avoid WinRT expression tree issue.
null,
Metadata._Type.GetTypeFromHandle,
Expression.Constant(m.Member.DeclaringType.TypeHandle)
)
)
),
refTargetParameter,
valueParameter
).Compile()
: UnpackHelpers.IsReadOnlyAppendableCollectionMember(m.Member)
? default(MemberSetter)
: ThrowGetOnlyMemberIsInvalid(m.Member)
).ToArray();
}
}
private static void EmitUnpackMembersFromArray(SerializerEmitter emitter, TracingILGenerator unpackerIL, SerializingMember[] entries, LocalBuilder result, LocalVariableHolder localHolder)
{
/*
* int unpacked = 0;
* int itemsCount = unpacker.ItemsCount;
*
* :
* if( unpacked == itemsCount )
* {
* HandleNilImplication(...);
* }
* else
* {
* #if PRIMITIVE
* if( !unpacker.ReadT( out local1 ) )
* {
* throw SerializationExceptions.NewUnexpectedEndOfStreamMethod();
* }
* #else
* if( !unpacker.Read() )
* {
* throw SerializationExceptions.NewUnexpectedEndOfStreamMethod();
* }
*
* local1 = this._serializer1.Unpack
* #endif
* unpacked++;
* }
* :
*/
// TODO: Supports ExtensionObject like round-tripping.
var itemsCount = localHolder.ItemsCount;
var unpacked = unpackerIL.DeclareLocal(typeof(int), "unpacked");
Emittion.EmitGetUnpackerItemsCountAsInt32(unpackerIL, 1, localHolder);
unpackerIL.EmitAnyStloc(itemsCount);
for (int i = 0; i < entries.Length; i++)
{
var endIf0 = unpackerIL.DefineLabel("END_IF");
var else0 = unpackerIL.DefineLabel("ELSE");
unpackerIL.EmitAnyLdloc(unpacked);
unpackerIL.EmitAnyLdloc(itemsCount);
unpackerIL.EmitBlt(else0);
// Tail missing member handling.
if (entries[i].Member != null)
{
// Respect nil implication.
Emittion.EmitNilImplication(unpackerIL, 1, entries[i].Contract.Name, entries[i].Contract.NilImplication, endIf0, localHolder);
}
unpackerIL.EmitBr(endIf0);
unpackerIL.MarkLabel(else0);
if (entries[i].Member == null)
{
Emittion.EmitGeneralRead(unpackerIL, 1);
// Ignore undefined member -- Nop.
}
else if (UnpackHelpers.IsReadOnlyAppendableCollectionMember(entries[i].Member))
{
Emittion.EmitDeserializeCollectionValue(
emitter,
unpackerIL,
1,
result,
entries[i].Member,
entries[i].Member.GetMemberValueType(),
entries[i].Contract.NilImplication,
localHolder
);
}
else
{
Emittion.EmitDeserializeValue(
emitter,
unpackerIL,
1,
result,
entries[i],
localHolder
);
}
unpackerIL.EmitAnyLdloc(unpacked);
unpackerIL.EmitLdc_I4_1();
unpackerIL.EmitAdd();
unpackerIL.EmitAnyStloc(unpacked);
unpackerIL.MarkLabel(endIf0);
}
}
