public ParameterMetadata MapUp(BaseParameter model)
{
ParameterMetadata parameterModel = new ParameterMetadata();
parameterModel.Name = model.Name;
Type type = model.GetType();
PropertyInfo typeProperty = type.GetProperty("Type",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
BaseType typeModel = (BaseType)typeProperty?.GetValue(model);
if (typeModel != null)
{
parameterModel.Type = MapperType.EmitType(typeModel);
}
return(parameterModel);
}
public BaseParameter MapDown(ParameterMetadata model, Type parameterModelType)
{
object parameterModel = Activator.CreateInstance(parameterModelType);
PropertyInfo nameProperty = parameterModelType.GetProperty("Name");
PropertyInfo typeProperty = parameterModelType.GetProperty("Type",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(parameterModel, model.Name);
if (model.Type != null)
{
typeProperty?.SetValue(parameterModel,
typeProperty.PropertyType.Cast(MapperType.EmitBaseType(model.Type, typeProperty.PropertyType)));
}
return((BaseParameter)parameterModel);
}
public NamespaceMetadata MapUp(BaseNamespace model)
{
NamespaceMetadata namespaceModel = new NamespaceMetadata();
namespaceModel.Name = model.Name;
Type type = model.GetType();
PropertyInfo typesProperty = type.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <BaseType> types = (List <BaseType>)Converter.ConvertList(typeof(BaseType), (IList)typesProperty?.GetValue(model));
if (types != null)
{
namespaceModel.Types = types.Select(n => MapperType.EmitType(n)).ToList();
}
return(namespaceModel);
}
public MethodMetadata MapUp(BaseMethod model)
{
MethodMetadata methodModel = new MethodMetadata();
methodModel.Name = model.Name;
methodModel.Extension = model.Extension;
Type type = model.GetType();
PropertyInfo genericArgumentsProperty = type.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (genericArgumentsProperty?.GetValue(model) != null)
{
List <BaseType> genericArguments =
(List <BaseType>)Converter.ConvertList(typeof(BaseType),
(IList)genericArgumentsProperty?.GetValue(model));
methodModel.GenericArguments =
genericArguments.Select(g => MapperType.EmitType(g)).ToList();
}
methodModel.Modifiers = model.Modifiers;
PropertyInfo parametersProperty = type.GetProperty("Parameters",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (parametersProperty?.GetValue(model) != null)
{
List <BaseParameter> parameters =
(List <BaseParameter>)Converter.ConvertList(typeof(BaseParameter),
(IList)parametersProperty?.GetValue(model));
methodModel.Parameters = parameters
.Select(p => new MapperParameter().MapUp(p)).ToList();
}
PropertyInfo returnTypeProperty = type.GetProperty("ReturnType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
BaseType returnType = (BaseType)returnTypeProperty?.GetValue(model);
if (returnType != null)
{
methodModel.ReturnType = MapperType.EmitType(returnType);
}
return(methodModel);
}
public BaseMethod MapDown(MethodMetadata model, Type methodModelType)
{
object methodModel = Activator.CreateInstance(methodModelType);
PropertyInfo nameProperty = methodModelType.GetProperty("Name");
PropertyInfo extensionProperty = methodModelType.GetProperty("Extension");
PropertyInfo genericArgumentsProperty = methodModelType.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
PropertyInfo modifiersProperty = methodModelType.GetProperty("Modifiers");
PropertyInfo parametersProperty = methodModelType.GetProperty("Parameters",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
PropertyInfo returnTypeProperty = methodModelType.GetProperty("ReturnType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(methodModel, model.Name);
extensionProperty?.SetValue(methodModel, model.Extension);
if (model.GenericArguments != null)
{
genericArgumentsProperty?.SetValue(methodModel,
Converter.ConvertList(genericArgumentsProperty.PropertyType.GetGenericArguments()[0],
model.GenericArguments.Select(t => MapperType.EmitBaseType(t, genericArgumentsProperty.PropertyType.GetGenericArguments()[0])).ToList()));
}
modifiersProperty?.SetValue(methodModel, model.Modifiers);
if (model.Parameters != null)
{
parametersProperty?.SetValue(methodModel,
Converter.ConvertList(parametersProperty.PropertyType.GetGenericArguments()[0],
model.Parameters.Select(p => new MapperParameter().MapDown(p, parametersProperty.PropertyType.GetGenericArguments()[0])).ToList()));
}
if (model.ReturnType != null)
{
returnTypeProperty?.SetValue(methodModel,
returnTypeProperty.PropertyType.Cast(MapperType.EmitBaseType(model.ReturnType, returnTypeProperty.PropertyType)));
}
return((BaseMethod)methodModel);
}
