public IEnumerable <SerializerCodeGenerationResult> Generate(IEnumerable <Type> targetTypes, TConfig configuration)
{
if (targetTypes == null)
{
throw new ArgumentNullException("targetTypes");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
configuration.Validate();
var context =
new SerializationContext
{
SerializationMethod = configuration.SerializationMethod,
SerializerOptions =
{
#if FEATURE_TAP
WithAsync = configuration.WithAsync,
#endif // FEATURE_TAP
GeneratorOption = SerializationMethodGeneratorOption.CanDump,
EmitterFlavor = this.EmitterFlavor
},
EnumSerializationOptions =
{
SerializationMethod = configuration.EnumSerializationMethod
},
CompatibilityOptions =
{
AllowNonCollectionEnumerableTypes = configuration.CompatibilityOptions.AllowNonCollectionEnumerableTypes,
IgnorePackabilityForCollection = configuration.CompatibilityOptions.IgnorePackabilityForCollection,
OneBoundDataMemberOrder = configuration.CompatibilityOptions.OneBoundDataMemberOrder,
PackerCompatibilityOptions = configuration.CompatibilityOptions.PackerCompatibilityOptions
}
};
IEnumerable <Type> realTargetTypes;
if (configuration.IsRecursive)
{
realTargetTypes =
targetTypes
.SelectMany(t => ExtractElementTypes(context, configuration, t));
}
else
{
realTargetTypes =
targetTypes
.Where(t => !SerializationTarget.BuiltInSerializerExists(configuration, t, t.GetCollectionTraits(CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes)));
}
var generationContext = this.CreateGenerationContext(context, configuration);
var generatorFactory = this.CreateGeneratorFactory(context);
foreach (var targetType in realTargetTypes.Distinct())
{
var generator = generatorFactory(targetType);
var concreteType = default(Type);
if (targetType.GetIsInterface() || targetType.GetIsAbstract())
{
concreteType = context.DefaultCollectionTypes.GetConcreteType(targetType);
}
generator.BuildSerializerCode(generationContext, concreteType, null);
}
Directory.CreateDirectory(configuration.OutputDirectory);
return(generationContext.Generate());
}
internal static MessagePackSerializer <T> CreateReflectionInternal <T>(SerializationContext context, Type concreteType, PolymorphismSchema schema)
{
if (concreteType.GetIsAbstract() || concreteType.GetIsInterface())
{
// return null for polymoirphic provider.
return(null);
}
var serializer = context.Serializers.Get <T>(context);
if (serializer != null)
{
// For MessagePack.Create compatibility.
// Required for built-in types.
return(serializer);
}
ValidateType(typeof(T));
var traits =
#if !UNITY
typeof(T).GetCollectionTraits(CollectionTraitOptions.WithAddMethod, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#else
typeof(T).GetCollectionTraits(CollectionTraitOptions.WithAddMethod | CollectionTraitOptions.WithCountPropertyGetter, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#endif
switch (traits.CollectionType)
{
case CollectionKind.Array:
case CollectionKind.Map:
{
return
(#if !UNITY
ReflectionSerializerHelper.CreateCollectionSerializer <T>(context, concreteType, traits, (schema ?? PolymorphismSchema.Default)));
#else
Wrap <T>(
context,
ReflectionSerializerHelper.CreateCollectionSerializer <T>(context, concreteType, traits, (schema ?? PolymorphismSchema.Default))
);
#endif // !UNITY
}
default:
{
if (typeof(T).GetIsEnum())
{
return(ReflectionSerializerHelper.CreateReflectionEnumMessagePackSerializer <T>(context));
}
#if !NETFX_35 && !UNITY
if (TupleItems.IsTuple(typeof(T)))
{
return
(new ReflectionTupleMessagePackSerializer <T>(
context,
(schema ?? PolymorphismSchema.Default).ChildSchemaList
));
}
#endif // !NETFX_35 && !UNITY
SerializationTarget.VerifyType(typeof(T));
var target = SerializationTarget.Prepare(context, typeof(T));
return(new ReflectionObjectMessagePackSerializer <T>(context, target, target.GetCapabilitiesForObject()));
}
}
}
