protected override void EmitPackMembers(SerializerEmitter emitter, TracingILGenerator packerIL, SerializingMember[] entries)
{
var localHolder = new LocalVariableHolder(packerIL);
packerIL.EmitAnyLdarg(1);
packerIL.EmitAnyLdc_I4(entries.Length);
packerIL.EmitAnyCall(Metadata._Packer.PackArrayHeader);
packerIL.EmitPop();
foreach (var member in entries)
{
if (member.Member == null)
{
// missing member, always nil
packerIL.EmitAnyLdarg(1);
packerIL.EmitAnyCall(Metadata._Packer.PackNull);
packerIL.EmitPop();
}
else
{
Emittion.EmitSerializeValue(
emitter,
packerIL,
1,
member.Member.GetMemberValueType(),
member.Member.Name,
member.Contract.NilImplication,
il =>
{
if (typeof(TObject).IsValueType)
{
il.EmitAnyLdarga(2);
}
else
{
il.EmitAnyLdarg(2);
}
Emittion.EmitLoadValue(il, member.Member);
},
localHolder
);
}
}
packerIL.EmitRet();
}
protected sealed override void EmitPackMembers(SerializerEmitter emitter, TracingILGenerator packerIL, SerializingMember[] entries)
{
var localHolder = new LocalVariableHolder(packerIL);
packerIL.EmitAnyLdarg(1);
packerIL.EmitAnyLdc_I4(entries.Length);
packerIL.EmitAnyCall(Metadata._Packer.PackMapHeader);
packerIL.EmitPop();
foreach (var entry in entries)
{
if (entry.Member == null)
{
// skip undefined member.
continue;
}
packerIL.EmitAnyLdarg(1);
packerIL.EmitLdstr(entry.Contract.Name);
packerIL.EmitAnyCall(Metadata._Packer.PackString);
packerIL.EmitPop();
Emittion.EmitSerializeValue(
emitter,
packerIL,
1,
entry.Member.GetMemberValueType(),
entry.Contract.Name,
entry.Contract.NilImplication,
il0 =>
{
if (typeof(TObject).IsValueType)
{
il0.EmitAnyLdarga(2);
}
else
{
il0.EmitAnyLdarg(2);
}
Emittion.EmitLoadValue(il0, entry.Member);
},
localHolder
);
}
packerIL.EmitRet();
}
protected override void EmitPackMembers(SerializerEmitter emitter, TracingILGenerator packerIL, SerializingMember[] entries)
{
LocalVariableHolder localHolder = new LocalVariableHolder(packerIL);
packerIL.EmitAnyLdarg(1);
packerIL.EmitAnyLdc_I4(entries.Length);
packerIL.EmitAnyCall(_Packer.PackArrayHeader);
packerIL.EmitPop();
SerializingMember[] memberArray = entries;
for (int i = 0; i < memberArray.Length; i++)
{
Action <TracingILGenerator> loadValueEmitter = null;
SerializingMember member = memberArray[i];
if (member.Member == null)
{
packerIL.EmitAnyLdarg(1);
packerIL.EmitAnyCall(_Packer.PackNull);
packerIL.EmitPop();
}
else
{
if (loadValueEmitter == null)
{
loadValueEmitter = delegate(TracingILGenerator il) {
if (typeof(TObject).IsValueType)
{
il.EmitAnyLdarga(2);
}
else
{
il.EmitAnyLdarg(2);
}
Emittion.EmitLoadValue(il, member.Member);
};
}
Emittion.EmitSerializeValue(emitter, packerIL, 1, member.Member.GetMemberValueType(), member.Member.Name, member.Contract.NilImplication, loadValueEmitter, localHolder);
}
}
packerIL.EmitRet();
}
private static void CreateTuplePack(SerializerEmitter emiter, Type tupleType, IList <Type> itemTypes, Action <TracingILGenerator, LocalBuilder> loadTupleEmitter)
{
var il = emiter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder(il);
try
{
/*
* packer.PackArrayHeader( cardinarity );
* _serializer0.PackTo( packer, tuple.Item1 );
* :
* _serializer6.PackTo( packer, tuple.item7 );
* _serializer7.PackTo( packer, tuple.Rest.Item1 );
*/
var tuple = il.DeclareLocal(tupleType, "tuple");
loadTupleEmitter(il, tuple);
il.EmitAnyLdarg(1);
il.EmitAnyLdc_I4(itemTypes.Count);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
var tupleTypeList = TupleItems.CreateTupleTypeList(itemTypes);
int depth = -1;
for (int i = 0; i < itemTypes.Count; i++)
{
if (i % 7 == 0)
{
depth++;
}
Emittion.EmitSerializeValue(
emiter,
il,
1,
itemTypes[i],
null,
NilImplication.MemberDefault,
il0 =>
{
il0.EmitAnyLdloc(tuple);
for (int j = 0; j < depth; j++)
{
// .TRest.TRest ...
var rest = tupleTypeList[j].GetProperty("Rest");
il0.EmitGetProperty(rest);
}
var itemn = tupleTypeList[depth].GetProperty("Item" + ((i % 7) + 1));
#if DEBUG
Contract.Assert(itemn != null, tupleTypeList[depth].GetFullName() + "::Item" + ((i % 7) + 1) + " [ " + depth + " ] @ " + i);
#endif
il0.EmitGetProperty(itemn);
},
localHolder
);
}
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreatePackArrayProceduresCore(Type targetType, SerializerEmitter emitter, CollectionTraits traits)
{
var il = emitter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder(il);
try
{
// Array
if (targetType.IsArray)
{
/*
* // array
* packer.PackArrayHeader( length );
* for( int i = 0; i < length; i++ )
* {
* this._serializer.PackTo( packer, collection[ i ] );
* }
*/
var length = localHolder.PackingCollectionCount;
il.EmitAnyLdarg(2);
il.EmitLdlen();
il.EmitAnyStloc(length);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(length);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
Emittion.EmitFor(
il,
length,
(il0, i) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdarg(2);
il1.EmitAnyLdloc(i);
il1.EmitLdelem(traits.ElementType);
},
localHolder
)
);
}
else if (traits.CountProperty == null)
{
/*
* array = collection.ToArray();
* packer.PackArrayHeader( length );
* for( int i = 0; i < length; i++ )
* {
* this._serializer.PackTo( packer, array[ i ] );
* }
*/
var array = localHolder.GetSerializingCollection(traits.ElementType.MakeArrayType());
EmitLoadTarget(targetType, il, 2);
il.EmitAnyCall(Metadata._Enumerable.ToArray1Method.MakeGenericMethod(traits.ElementType));
il.EmitAnyStloc(array);
var length = localHolder.PackingCollectionCount;
il.EmitAnyLdloc(array);
il.EmitLdlen();
il.EmitAnyStloc(length);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(length);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
Emittion.EmitFor(
il,
length,
(il0, i) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloc(array);
il1.EmitAnyLdloc(i);
il1.EmitLdelem(traits.ElementType);
},
localHolder
)
);
}
else
{
/*
* // Enumerable
* packer.PackArrayHeader( collection.Count );
* foreach( var item in list )
* {
* this._serializer.PackTo( packer, array[ i ] );
* }
*/
var collection = localHolder.GetSerializingCollection(targetType);
// This instruction always ldarg, not to be ldarga
il.EmitAnyLdarg(2);
il.EmitAnyStloc(collection);
var count = localHolder.PackingCollectionCount;
EmitLoadTarget(targetType, il, 2);
il.EmitGetProperty(traits.CountProperty);
il.EmitAnyStloc(count);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(count);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
Emittion.EmitForEach(
il,
traits,
collection,
(il0, getCurrentEmitter) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
_ => getCurrentEmitter(),
localHolder
)
);
}
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreateMapPack(Type targetType, SerializerEmitter emiter, CollectionTraits traits)
{
var il = emiter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder(il);
try
{
/*
* int count = ((ICollection<KeyValuePair<string, DateTime>>)dictionary).Count;
* packer.PackMapHeader(count);
* foreach (KeyValuePair<string, DateTime> current in dictionary)
* {
* this._serializer0.PackTo(packer, current.Key);
* this._serializer1.PackTo(packer, current.Value);
* }
*/
var collection = localHolder.GetSerializingCollection(targetType);
var item = localHolder.GetSerializingCollectionItem(traits.ElementType);
var keyProperty = traits.ElementType.GetProperty("Key");
var valueProperty = traits.ElementType.GetProperty("Value");
// This instruction is always ldarg, not to be ldarga.
il.EmitAnyLdarg(2);
il.EmitAnyStloc(collection);
var count = localHolder.PackingCollectionCount;
EmitLoadTarget(targetType, il, collection);
il.EmitGetProperty(traits.CountProperty);
il.EmitAnyStloc(count);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(count);
il.EmitAnyCall(Metadata._Packer.PackMapHeader);
il.EmitPop();
Emittion.EmitForEach(
il,
traits,
collection,
(il0, getCurrentEmitter) =>
{
if (traits.ElementType.IsGenericType)
{
Contract.Assert(traits.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>));
getCurrentEmitter();
il0.EmitAnyStloc(item);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
traits.ElementType.GetGenericArguments()[0],
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(keyProperty);
},
localHolder
);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
traits.ElementType.GetGenericArguments()[1],
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(valueProperty);
},
localHolder
);
}
else
{
Contract.Assert(traits.ElementType == typeof(DictionaryEntry));
getCurrentEmitter();
il0.EmitAnyStloc(item);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
typeof(MessagePackObject),
null,
NilImplication.MemberDefault,
il1 =>
{
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(Metadata._DictionaryEntry.Key);
il0.EmitUnbox_Any(typeof(MessagePackObject));
},
localHolder
);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
typeof(MessagePackObject),
null,
NilImplication.MemberDefault,
il1 =>
{
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(Metadata._DictionaryEntry.Value);
il0.EmitUnbox_Any(typeof(MessagePackObject));
},
localHolder
);
}
}
);
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreateMapPack(Type targetType, SerializerEmitter emiter, CollectionTraits traits)
{
TracingILGenerator packToMethodILGenerator = emiter.GetPackToMethodILGenerator();
LocalVariableHolder localHolder = new LocalVariableHolder(packToMethodILGenerator);
try
{
< > c__DisplayClass20 class3;
LocalBuilder serializingCollection = localHolder.GetSerializingCollection(targetType);
LocalBuilder item = localHolder.GetSerializingCollectionItem(traits.ElementType);
PropertyInfo keyProperty = traits.ElementType.GetProperty("Key");
PropertyInfo valueProperty = traits.ElementType.GetProperty("Value");
packToMethodILGenerator.EmitAnyLdarg(2);
packToMethodILGenerator.EmitAnyStloc(serializingCollection);
LocalBuilder packingCollectionCount = localHolder.PackingCollectionCount;
EmitLoadTarget(targetType, packToMethodILGenerator, serializingCollection);
packToMethodILGenerator.EmitGetProperty(traits.CountProperty);
packToMethodILGenerator.EmitAnyStloc(packingCollectionCount);
packToMethodILGenerator.EmitAnyLdarg(1);
packToMethodILGenerator.EmitAnyLdloc(packingCollectionCount);
packToMethodILGenerator.EmitAnyCall(_Packer.PackMapHeader);
packToMethodILGenerator.EmitPop();
Emittion.EmitForEach(packToMethodILGenerator, traits, serializingCollection, delegate(TracingILGenerator il0, Action getCurrentEmitter) {
Action <TracingILGenerator> loadValueEmitter = null;
Action <TracingILGenerator> action2 = null;
Action <TracingILGenerator> action3 = null;
Action <TracingILGenerator> action4 = null;
< > c__DisplayClass20 class1 = class3;
if (traits.ElementType.IsGenericType)
{
Contract.Assert(traits.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>));
getCurrentEmitter();
il0.EmitAnyStloc(item);
if (loadValueEmitter == null)
{
loadValueEmitter = delegate(TracingILGenerator il1) {
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(keyProperty);
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, traits.ElementType.GetGenericArguments()[0], null, NilImplication.MemberDefault, loadValueEmitter, localHolder);
if (action2 == null)
{
action2 = delegate(TracingILGenerator il1) {
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(valueProperty);
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, traits.ElementType.GetGenericArguments()[1], null, NilImplication.MemberDefault, action2, localHolder);
}
else
{
Contract.Assert(traits.ElementType == typeof(DictionaryEntry));
getCurrentEmitter();
il0.EmitAnyStloc(item);
if (action3 == null)
{
action3 = delegate(TracingILGenerator il1) {
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(_DictionaryEntry.Key);
il0.EmitUnbox_Any(typeof(MessagePackObject));
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, action3, localHolder);
if (action4 == null)
{
action4 = delegate(TracingILGenerator il1) {
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(_DictionaryEntry.Value);
il0.EmitUnbox_Any(typeof(MessagePackObject));
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, action4, localHolder);
}
});
