public NamespaceModel MapDown(NamespaceMetadata model, Type NamespaceMetadataType)
{
object NamespaceMetadata = Activator.CreateInstance(NamespaceMetadataType);
PropertyInfo nameProperty = NamespaceMetadataType.GetProperty("Name");
PropertyInfo NamespaceMetadatasProperty = NamespaceMetadataType.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(NamespaceMetadata, model.Name);
NamespaceMetadatasProperty?.SetValue(NamespaceMetadata,
HelperClass.ConvertList(NamespaceMetadatasProperty.PropertyType.GetGenericArguments()[0],
model.Types.Select(t => new TypeModelMapper().MapDown(t, NamespaceMetadatasProperty.PropertyType.GetGenericArguments()[0])).ToList()));
return((NamespaceModel)NamespaceMetadata);
}
public static AssemblyModel MapDown(AssemblyMetadata model, AssemblyModel assemblyModelType)
{
AssemblyModel assemblyModel = assemblyModelType;// Activator.CreateInstance(assemblyModelType);
PropertyInfo nameProperty = assemblyModelType.GetType().GetProperty("Name");
PropertyInfo namespaceModelsProperty = assemblyModelType.GetType().GetProperty("NamespaceModels",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(assemblyModel, model.Name);
namespaceModelsProperty?.SetValue(
assemblyModel,
HelperClass.ConvertList(namespaceModelsProperty.PropertyType.GetGenericArguments()[0],
model.Namespaces.Select(n => new NamespaceModelMapper().MapDown(n, namespaceModelsProperty.PropertyType.GetGenericArguments()[0])).ToList()));
return((AssemblyModel)assemblyModel);
}
public NamespaceMetadata MapUp(NamespaceModel model)
{
NamespaceMetadata NamespaceMetadata = new NamespaceMetadata();
NamespaceMetadata.Name = model.Name;
Type type = model.GetType();
PropertyInfo typesProperty = type.GetProperty("Types",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <TypeModel> types = (List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel), (IList)typesProperty?.GetValue(model));
if (types != null)
{
NamespaceMetadata.Types = types.Select(n => TypeModelMapper.EmitType(n)).ToList();
}
return(NamespaceMetadata);
}
public static AssemblyMetadata MapUp(AssemblyModel model)
{
AssemblyMetadata assemblyModel = new AssemblyMetadata();
Type type = model.GetType();
assemblyModel.Name = model.Name;
PropertyInfo namespaceModelsProperty = type.GetProperty("NamespaceModels",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <NamespaceModel> namespaceModels = (List <NamespaceModel>)HelperClass.ConvertList(typeof(NamespaceModel), (IList)namespaceModelsProperty?.GetValue(model));
if (namespaceModels != null)
{
assemblyModel.Namespaces = namespaceModels.Select(n => new NamespaceModelMapper().MapUp(n)).ToList();
}
return(assemblyModel);
}
public MethodMetadata MapUp(MethodModel model)
{
MethodMetadata MethodMetadata = new MethodMetadata();
MethodMetadata.Name = model.Name;
MethodMetadata.Extension = model.Extension;
Type type = model.GetType();
PropertyInfo genericArgumentsProperty = type.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (genericArgumentsProperty?.GetValue(model) != null)
{
List <TypeModel> genericArguments =
(List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel),
(IList)genericArgumentsProperty?.GetValue(model));
MethodMetadata.GenericArguments =
genericArguments.Select(g => TypeModelMapper.EmitType(g)).ToList();
}
MethodMetadata.Modifiers = model.Modifiers;
PropertyInfo parametersProperty = type.GetProperty("Parameters",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (parametersProperty?.GetValue(model) != null)
{
List <ParameterModel> parameters =
(List <ParameterModel>)HelperClass.ConvertList(typeof(ParameterModel),
(IList)parametersProperty?.GetValue(model));
MethodMetadata.Parameters = parameters
.Select(p => new ParameterModelMapper().MapUp(p)).ToList();
}
PropertyInfo returnTypeProperty = type.GetProperty("ReturnType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
TypeModel returnType = (TypeModel)returnTypeProperty?.GetValue(model);
if (returnType != null)
{
MethodMetadata.ReturnType = TypeModelMapper.EmitType(returnType);
}
return(MethodMetadata);
}
public MethodModel MapDown(MethodMetadata model, Type MethodMetadataType)
{
object MethodMetadata = Activator.CreateInstance(MethodMetadataType);
PropertyInfo nameProperty = MethodMetadataType.GetProperty("Name");
PropertyInfo extensionProperty = MethodMetadataType.GetProperty("Extension");
PropertyInfo genericArgumentsProperty = MethodMetadataType.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
PropertyInfo modifiersProperty = MethodMetadataType.GetProperty("Modifiers");
PropertyInfo parametersProperty = MethodMetadataType.GetProperty("Parameters",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
PropertyInfo returnTypeProperty = MethodMetadataType.GetProperty("ReturnType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(MethodMetadata, model.Name);
extensionProperty?.SetValue(MethodMetadata, model.Extension);
if (model.GenericArguments != null)
{
genericArgumentsProperty?.SetValue(MethodMetadata,
HelperClass.ConvertList(genericArgumentsProperty.PropertyType.GetGenericArguments()[0],
model.GenericArguments.Select(t => TypeModelMapper.EmitBaseType(t, genericArgumentsProperty.PropertyType.GetGenericArguments()[0])).ToList()));
}
modifiersProperty?.SetValue(MethodMetadata, model.Modifiers);
if (model.Parameters != null)
{
parametersProperty?.SetValue(MethodMetadata,
HelperClass.ConvertList(parametersProperty.PropertyType.GetGenericArguments()[0],
model.Parameters.Select(p => new ParameterModelMapper().MapDown(p, parametersProperty.PropertyType.GetGenericArguments()[0])).ToList()));
}
if (model.ReturnType != null)
{
returnTypeProperty?.SetValue(MethodMetadata,
returnTypeProperty.PropertyType.Cast(TypeModelMapper.EmitBaseType(model.ReturnType, returnTypeProperty.PropertyType)));
}
return((MethodModel)MethodMetadata);
}
private void FillBaseType(TypeMetadata model, TypeModel typModel)
{
Type typeModelType = typModel.GetType();
typeModelType.GetProperty("Name")?.SetValue(typModel, model.Name);
typeModelType.GetProperty("IsExternal")?.SetValue(typModel, model.IsExternal);
typeModelType.GetProperty("IsGeneric")?.SetValue(typModel, model.IsGeneric);
typeModelType.GetProperty("Type")?.SetValue(typModel, model.Type);
typeModelType.GetProperty("AssemblyName")?.SetValue(typModel, model.Name);
typeModelType.GetProperty("Modifiers")?.SetValue(typModel, model.Modifiers ?? new TypeModifiers());
if (model.BaseType != null)
{
typeModelType.GetProperty("BaseType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
?.SetValue(typModel, typeModelType.Cast(EmitBaseType(model.BaseType, typeModelType)));
}
if (model.DeclaringType != null)
{
typeModelType.GetProperty("DeclaringType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
?.SetValue(typModel, typeModelType.Cast(EmitBaseType(model.DeclaringType, typeModelType)));
}
if (model.NestedTypes != null)
{
PropertyInfo nestedTypesProperty = typeModelType.GetProperty("NestedTypes",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nestedTypesProperty?.SetValue(typModel,
HelperClass.ConvertList(typeModelType,
model.NestedTypes?.Select(c => EmitBaseType(c, typeModelType)).ToList()));
}
if (model.GenericArguments != null)
{
PropertyInfo genericArgumentsProperty = typeModelType.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
genericArgumentsProperty?.SetValue(typModel,
HelperClass.ConvertList(typeModelType,
model.GenericArguments?.Select(c => EmitBaseType(c, typeModelType)).ToList()));
}
if (model.ImplementedInterfaces != null)
{
PropertyInfo implementedInterfacesProperty = typeModelType.GetProperty("ImplementedInterfaces",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
implementedInterfacesProperty?.SetValue(typModel,
HelperClass.ConvertList(typeModelType,
model.ImplementedInterfaces?.Select(c => EmitBaseType(c, typeModelType)).ToList()));
}
if (model.Fields != null)
{
PropertyInfo fieldsProperty = typeModelType.GetProperty("Fields",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
fieldsProperty?.SetValue(typModel,
HelperClass.ConvertList(fieldsProperty.PropertyType.GetGenericArguments()[0],
model.Fields?.Select(c =>
new ParameterModelMapper().MapDown(c,
fieldsProperty?.PropertyType.GetGenericArguments()[0])).ToList()));
}
if (model.Methods != null)
{
PropertyInfo methodsProperty = typeModelType.GetProperty("Methods",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
methodsProperty?.SetValue(typModel,
HelperClass.ConvertList(methodsProperty.PropertyType.GetGenericArguments()[0],
model.Methods?.Select(m =>
new MethodModelMapper().MapDown(m,
methodsProperty?.PropertyType.GetGenericArguments()[0]))
.ToList()));
}
if (model.Constructors != null)
{
PropertyInfo constructorsProperty = typeModelType.GetProperty("Constructors",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
constructorsProperty?.SetValue(typModel,
HelperClass.ConvertList(constructorsProperty.PropertyType.GetGenericArguments()[0],
model.Constructors?.Select(c =>
new MethodModelMapper().MapDown(c,
constructorsProperty?.PropertyType.GetGenericArguments()[0])).ToList()));
}
if (model.Properties != null)
{
PropertyInfo propertiesProperty = typeModelType.GetProperty("Properties",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
propertiesProperty?.SetValue(typModel,
HelperClass.ConvertList(propertiesProperty.PropertyType.GetGenericArguments()[0],
model.Properties?.Select(c =>
new PropertyModelMapper().MapDown(c,
propertiesProperty?.PropertyType.GetGenericArguments()[0])).ToList()));
}
}
private void FillType(TypeModel model, TypeMetadata TypeMetadata)
{
TypeMetadata.Name = model.Name;
TypeMetadata.IsExternal = model.IsExternal;
TypeMetadata.IsGeneric = model.IsGeneric;
TypeMetadata.Type = model.Type;
TypeMetadata.Name = model.AssemblyName;
TypeMetadata.Modifiers = model.Modifiers ?? new TypeModifiers();
Type type = model.GetType();
PropertyInfo baseTypeProperty = type.GetProperty("BaseType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
TypeModel baseType = (TypeModel)baseTypeProperty?.GetValue(model);
TypeMetadata.BaseType = EmitType(baseType);
PropertyInfo declaringTypeProperty = type.GetProperty("DeclaringType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
TypeModel declaringType = (TypeModel)declaringTypeProperty?.GetValue(model);
TypeMetadata.DeclaringType = EmitType(declaringType);
PropertyInfo nestedTypesProperty = type.GetProperty("NestedTypes",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (nestedTypesProperty?.GetValue(model) != null)
{
List <TypeModel> nestedTypes = (List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel),
(IList)nestedTypesProperty?.GetValue(model));
TypeMetadata.NestedTypes = nestedTypes?.Select(n => EmitType(n)).ToList();
}
PropertyInfo genericArgumentsProperty = type.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (genericArgumentsProperty?.GetValue(model) != null)
{
List <TypeModel> genericArguments =
(List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel),
(IList)genericArgumentsProperty?.GetValue(model));
TypeMetadata.GenericArguments = genericArguments?.Select(g => EmitType(g)).ToList();
}
PropertyInfo implementedInterfacesProperty = type.GetProperty("ImplementedInterfaces",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (implementedInterfacesProperty?.GetValue(model) != null)
{
List <TypeModel> implementedInterfaces =
(List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel),
(IList)implementedInterfacesProperty?.GetValue(model));
TypeMetadata.ImplementedInterfaces =
implementedInterfaces?.Select(i => EmitType(i)).ToList();
}
PropertyInfo fieldsProperty = type.GetProperty("Fields",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (fieldsProperty?.GetValue(model) != null)
{
List <ParameterModel> fields =
(List <ParameterModel>)HelperClass.ConvertList(typeof(ParameterModel),
(IList)fieldsProperty?.GetValue(model));
TypeMetadata.Fields = fields?.Select(g => new ParameterModelMapper().MapUp(g))
.ToList();
}
PropertyInfo methodsProperty = type.GetProperty("Methods",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (methodsProperty?.GetValue(model) != null)
{
List <MethodModel> methods = (List <MethodModel>)HelperClass.ConvertList(typeof(MethodModel),
(IList)methodsProperty?.GetValue(model));
TypeMetadata.Methods = methods?.Select(c => new MethodModelMapper().MapUp(c)).ToList();
}
PropertyInfo constructorsProperty = type.GetProperty("Constructors",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (constructorsProperty?.GetValue(model) != null)
{
List <MethodModel> constructors =
(List <MethodModel>)HelperClass.ConvertList(typeof(MethodModel),
(IList)constructorsProperty?.GetValue(model));
TypeMetadata.Constructors = constructors?.Select(c => new MethodModelMapper().MapUp(c))
.ToList();
}
PropertyInfo propertiesProperty = type.GetProperty("Properties",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (propertiesProperty?.GetValue(model) != null)
{
List <PropertyModel> properties =
(List <PropertyModel>)HelperClass.ConvertList(typeof(PropertyModel),
(IList)propertiesProperty?.GetValue(model));
TypeMetadata.Properties = properties?.Select(g => new PropertyModelMapper().MapUp(g))
.ToList();
}
}