private static DBTypeModel EmitDeclaringTypeDatabase(BaseTypeMetadata declaringType)
{
if (declaringType == null)
{
return(null);
}
return(EmitReferenceDatabase(declaringType));
}
public static IEnumerable <DBTypeModel> CheckGenericArgumentsDatabase(BaseTypeMetadata typeMetadata)
{
if (typeMetadata.GenericArguments != null)
{
return(EmitGenericArgumentsDatabase(typeMetadata.GenericArguments));
}
return(null);
}
private static DBTypeModel EmitExtendsDatabase(BaseTypeMetadata baseType)
{
if (baseType == null)
{
return(null);
}
return(EmitReferenceDatabase(baseType));
}
public ParameterMetadata MapUp(BaseParameterMetadata model)
{
ParameterMetadata parameterModel = new ParameterMetadata();
parameterModel.Name = model.Name;
Type type = model.GetType();
PropertyInfo typeProperty = type.GetProperty("Type",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
BaseTypeMetadata typeModel = (BaseTypeMetadata)typeProperty?.GetValue(model);
if (typeModel != null)
parameterModel.Type = TypeModelMapper.EmitType(typeModel);
return parameterModel;
}
internal static DBTypeModel EmitReferenceDatabase(BaseTypeMetadata type)
{
if (type == null)
{
return(null);
}
if (Dictionares.TypeDictonaryToDatabase.ContainsKey(type))
{
return(Dictionares.TypeDictonaryToDatabase[type]);
}
return(MapToDB(type));
}
public TypeMetadata MapUp(BaseTypeMetadata model)
{
TypeMetadata typeModel = new TypeMetadata();
if (model == null)
{
return(null);
}
if (!Types.ContainsKey(model.Name))
{
Types.Add(model.Name, typeModel);
FillType(model, typeModel);
}
return(Types[model.Name]);
}
public static DBTypeModel MapToDB(BaseTypeMetadata typeMetadata)
{
DBTypeModel DatabaseTypeMetadata = new DBTypeModel
{
TypeName = typeMetadata.TypeName,
DeclaringType = EmitDeclaringTypeDatabase(typeMetadata.DeclaringType),
Constructors = DBMethodMapper.EmitMethodsDatabase(typeMetadata.Constructors),
Methods = DBMethodMapper.EmitMethodsDatabase(typeMetadata.Methods),
NestedTypes = EmitNestedTypesDatabase(typeMetadata.NestedTypes),
ImplementedInterfaces = EmitImplementsDatabase(typeMetadata.ImplementedInterfaces),
GenericArguments = CheckGenericArgumentsDatabase(typeMetadata),
BaseType = EmitExtendsDatabase(typeMetadata.BaseType),
Properties = DBPropertyMapper.EmitPropertiesDatabase(typeMetadata.Properties),
};
return(DatabaseTypeMetadata);
}
public static XMLTypeModel GetOrAdd(BaseTypeMetadata baseType)
{
if (baseType != null)
{
if (TypeDictionary.ContainsKey(baseType.TypeName))
{
return(TypeDictionary[baseType.TypeName]);
}
else
{
return(new XMLTypeModel(baseType));
}
}
else
{
return(null);
}
}
public MethodMetadata MapUp(BaseMethodMetadata 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 <BaseTypeMetadata> genericArguments =
(List <BaseTypeMetadata>)HelperClass.ConvertList(typeof(BaseTypeMetadata),
(IList)genericArgumentsProperty?.GetValue(model));
methodModel.GenericArguments =
genericArguments.Select(g => TypeModelMapper.EmitType(g)).ToList();
}
methodModel.Modifiers = model.Modifiers;
PropertyInfo parametersProperty = type.GetProperty("Parameters",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (parametersProperty?.GetValue(model) != null)
{
List <BaseParameterMetadata> parameters =
(List <BaseParameterMetadata>)HelperClass.ConvertList(typeof(BaseParameterMetadata),
(IList)parametersProperty?.GetValue(model));
methodModel.Parameters = parameters
.Select(p => new ParameterModelMapper().MapUp(p)).ToList();
}
PropertyInfo returnTypeProperty = type.GetProperty("ReturnType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
BaseTypeMetadata returnType = (BaseTypeMetadata)returnTypeProperty?.GetValue(model);
if (returnType != null)
{
methodModel.ReturnType = TypeModelMapper.EmitType(returnType);
}
return(methodModel);
}
public XMLTypeModel(BaseTypeMetadata typeBase)
{
if (!TypeDictionary.ContainsKey(typeBase.TypeName))
{
TypeDictionary.Add(typeBase.TypeName, this);
}
TypeName = typeBase.TypeName;
NamespaceName = typeBase.NamespaceName;
TypeKind = typeBase.TypeKind;
BaseType = GetOrAdd(typeBase.BaseType);
DeclaringType = GetOrAdd(typeBase.DeclaringType);
Modifiers = new Tuple <AccessLevel, SealedEnum, AbstractEnum>(typeBase.Modifiers.Item1, typeBase.Modifiers.Item2, typeBase.Modifiers.Item3);
Constructors = typeBase.Constructors?.Select(c => new XMLMethodModel(c));
GenericArguments = typeBase.GenericArguments?.Select(GetOrAdd);
ImplementedInterfaces = typeBase.ImplementedInterfaces?.Select(GetOrAdd);
Methods = typeBase.Methods?.Select(m => new XMLMethodModel(m));
NestedTypes = typeBase.NestedTypes?.Select(GetOrAdd);
Properties = typeBase.Properties?.Select(p => new XMLPropertyModel(p));
}
public static DBTypeModel FillTypeDatabase(DBTypeModel DTGTypeMetadata, BaseTypeMetadata typeMetadata)
{
DTGTypeMetadata.TypeName = typeMetadata.TypeName;
DTGTypeMetadata.DeclaringType = EmitDeclaringTypeDatabase(typeMetadata.DeclaringType);
DTGTypeMetadata.Constructors = DBMethodMapper.EmitMethodsDatabase(typeMetadata.Constructors);
DTGTypeMetadata.Methods = DBMethodMapper.EmitMethodsDatabase(typeMetadata.Methods);
DTGTypeMetadata.NestedTypes = EmitNestedTypesDatabase(typeMetadata.NestedTypes);
DTGTypeMetadata.ImplementedInterfaces = EmitImplementsDatabase(typeMetadata.ImplementedInterfaces);
if (typeMetadata.GenericArguments != null)
{
DTGTypeMetadata.GenericArguments = EmitGenericArgumentsDatabase(typeMetadata.GenericArguments);
}
else
{
DTGTypeMetadata.GenericArguments = null;
}
//DTGTypeMetadata.Modifiers = EmitModifiers(typeMetadata);
DTGTypeMetadata.BaseType = EmitExtendsDatabase(typeMetadata.BaseType);
DTGTypeMetadata.Properties = DBPropertyMapper.EmitPropertiesDatabase(typeMetadata.Properties);
return(DTGTypeMetadata);
}
private void FillBaseType(TypeMetadata model, BaseTypeMetadata 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("NamespaceName")?.SetValue(typModel, model.NamespaceName); //?? assembly
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()));
}
}
public static TypeMetadata EmitType(BaseTypeMetadata model)
{
return(new TypeModelMapper().MapUp(model));
}
private void FillType(BaseTypeMetadata model, TypeMetadata typeModel)
{
typeModel.Name = model.Name;
//typeModel.IsExternal = model.IsExternal;
//typeModel.IsGeneric = model.IsGeneric;
typeModel.Type = model.Type;
typeModel.NamespaceName = model.NamespaceName;
typeModel.Modifiers = model.Modifiers; //?? new TypeModifiers();
Type type = model.GetType();
PropertyInfo baseTypeProperty = type.GetProperty("BaseType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
BaseTypeMetadata baseType = (BaseTypeMetadata)baseTypeProperty?.GetValue(model);
typeModel.BaseType = EmitType(baseType);
PropertyInfo declaringTypeProperty = type.GetProperty("DeclaringType",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
BaseTypeMetadata declaringType = (BaseTypeMetadata)declaringTypeProperty?.GetValue(model);
typeModel.DeclaringType = EmitType(declaringType);
PropertyInfo nestedTypesProperty = type.GetProperty("NestedTypes",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (nestedTypesProperty?.GetValue(model) != null)
{
List <BaseTypeMetadata> nestedTypes = (List <BaseTypeMetadata>)HelperClass.ConvertList(typeof(BaseTypeMetadata),
(IList)nestedTypesProperty?.GetValue(model));
typeModel.NestedTypes = nestedTypes?.Select(n => EmitType(n)).ToList();
}
PropertyInfo genericArgumentsProperty = type.GetProperty("GenericArguments",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (genericArgumentsProperty?.GetValue(model) != null)
{
List <BaseTypeMetadata> genericArguments =
(List <BaseTypeMetadata>)HelperClass.ConvertList(typeof(BaseTypeMetadata),
(IList)genericArgumentsProperty?.GetValue(model));
typeModel.GenericArguments = genericArguments?.Select(g => EmitType(g)).ToList();
}
PropertyInfo implementedInterfacesProperty = type.GetProperty("ImplementedInterfaces",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (implementedInterfacesProperty?.GetValue(model) != null)
{
List <BaseTypeMetadata> implementedInterfaces =
(List <BaseTypeMetadata>)HelperClass.ConvertList(typeof(BaseTypeMetadata),
(IList)implementedInterfacesProperty?.GetValue(model));
typeModel.ImplementedInterfaces =
implementedInterfaces?.Select(i => EmitType(i)).ToList();
}
PropertyInfo fieldsProperty = type.GetProperty("Fields",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (fieldsProperty?.GetValue(model) != null)
{
List <BaseParameterMetadata> fields =
(List <BaseParameterMetadata>)HelperClass.ConvertList(typeof(BaseParameterMetadata),
(IList)fieldsProperty?.GetValue(model));
typeModel.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 <BaseMethodMetadata> methods = (List <BaseMethodMetadata>)HelperClass.ConvertList(typeof(BaseMethodMetadata),
(IList)methodsProperty?.GetValue(model));
typeModel.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 <BaseMethodMetadata> constructors =
(List <BaseMethodMetadata>)HelperClass.ConvertList(typeof(BaseMethodMetadata),
(IList)constructorsProperty?.GetValue(model));
typeModel.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 <BasePropertyMetadata> properties =
(List <BasePropertyMetadata>)HelperClass.ConvertList(typeof(BasePropertyMetadata),
(IList)propertiesProperty?.GetValue(model));
typeModel.Properties = properties?.Select(g => new PropertyModelMapper().MapUp(g))
.ToList();
}
}
public TypeMetadata(BaseTypeMetadata typeMetadata)
{
m_typeName = typeMetadata.TypeName;
m_NamespaceName = typeMetadata.NamespaceName;
if (!BaseTypeMetadata.TypeDictionary.ContainsKey(m_typeName))
{
BaseTypeMetadata.TypeDictionary.Add(m_typeName, typeMetadata);
}
if (!m_typesMetadata.ContainsKey(m_typeName))
{
m_typesMetadata.Add(m_typeName, this);
}
if (typeMetadata.BaseType != null)
{
if (m_typesMetadata.ContainsKey(typeMetadata.BaseType.TypeName))
{
m_BaseType = m_typesMetadata[typeMetadata.BaseType.TypeName];
}
else
{
m_BaseType = new TypeMetadata(typeMetadata.BaseType);
}
}
if (typeMetadata.GenericArguments != null)
{
List <TypeMetadata> genericArguments = new List <TypeMetadata>();
foreach (BaseTypeMetadata baseMetadata in typeMetadata.GenericArguments)
{
TypeMetadata metadata;
if (m_typesMetadata.ContainsKey(baseMetadata.TypeName))
{
metadata = m_typesMetadata[baseMetadata.TypeName];
}
else
{
metadata = new TypeMetadata(baseMetadata);
}
genericArguments.Add(metadata);
}
m_GenericArguments = genericArguments;
}
m_Modifiers = typeMetadata.Modifiers;
//TypeKind = typeMetadata.TypeKind;
if (typeMetadata.ImplementedInterfaces != null)
{
List <TypeMetadata> interfaces = new List <TypeMetadata>();
foreach (BaseTypeMetadata baseMetadata in typeMetadata.ImplementedInterfaces)
{
TypeMetadata metadata;
if (m_typesMetadata.ContainsKey(typeMetadata.TypeName))
{
metadata = m_typesMetadata[typeMetadata.TypeName];
}
else
{
metadata = new TypeMetadata(typeMetadata);
}
interfaces.Add(metadata);
}
m_ImplementedInterfaces = interfaces;
}
if (typeMetadata.NestedTypes != null)
{
List <TypeMetadata> nestedTypes = new List <TypeMetadata>();
foreach (BaseTypeMetadata baseMetadata in typeMetadata.NestedTypes)
{
TypeMetadata metadata;
if (m_typesMetadata.ContainsKey(baseMetadata.TypeName))
{
metadata = m_typesMetadata[baseMetadata.TypeName];
}
else
{
metadata = new TypeMetadata(baseMetadata);
}
nestedTypes.Add(metadata);
}
m_NestedTypes = nestedTypes;
}
if (typeMetadata.Properties != null)
{
List <PropertyMetadata> properties = new List <PropertyMetadata>();
foreach (BasePropertyMetadata baseProperty in typeMetadata.Properties)
{
PropertyMetadata propertyMetadata = new PropertyMetadata(baseProperty);
properties.Add(propertyMetadata);
}
m_Properties = properties;
}
if (typeMetadata.DeclaringType != null)
{
if (m_typesMetadata.ContainsKey(typeMetadata.DeclaringType.TypeName))
{
m_DeclaringType = m_typesMetadata[typeMetadata.DeclaringType.TypeName];
}
else
{
m_DeclaringType = new TypeMetadata(typeMetadata.DeclaringType);
}
}
if (typeMetadata.Methods != null)
{
List <MethodMetadata> methods = new List <MethodMetadata>();
foreach (BaseMethodMetadata methodMetadata in typeMetadata.Methods)
{
MethodMetadata metadata = new MethodMetadata(methodMetadata);
methods.Add(metadata);
}
m_Methods = methods;
}
if (typeMetadata.Constructors != null)
{
List <MethodMetadata> constructors = new List <MethodMetadata>();
foreach (BaseMethodMetadata baseMetadata in typeMetadata.Constructors)
{
MethodMetadata methodMetadata = new MethodMetadata(baseMetadata);
constructors.Add(methodMetadata);
}
m_Constructors = constructors;
}
m_TypeKind = typeMetadata.TypeKind;
}
public BaseTypeMetadata MapUp()
{
BaseTypeMetadata TypeMetadataDTO = new BaseTypeMetadata();
TypeMetadataDTO.TypeName = m_typeName;
TypeMetadataDTO.NamespaceName = m_NamespaceName;
if (!BaseTypeMetadata.TypeDictionary.ContainsKey(this.m_typeName))
{
BaseTypeMetadata.TypeDictionary.Add(this.m_typeName, TypeMetadataDTO);
}
if (m_BaseType != null)
{
if (BaseTypeMetadata.TypeDictionary.ContainsKey(m_BaseType.m_typeName))
{
TypeMetadataDTO.BaseType = BaseTypeMetadata.TypeDictionary[m_BaseType.m_typeName];
}
else
{
TypeMetadataDTO.BaseType = m_BaseType.MapUp();
}
}
if (m_GenericArguments != null)
{
List <BaseTypeMetadata> GenericArgumentsDTO = new List <BaseTypeMetadata>();
foreach (TypeMetadata metadata in m_GenericArguments)
{
BaseTypeMetadata baseTypeMetadata;
if (BaseTypeMetadata.TypeDictionary.ContainsKey(metadata.m_typeName))
{
baseTypeMetadata = BaseTypeMetadata.TypeDictionary[metadata.m_typeName];
}
else
{
baseTypeMetadata = metadata.MapUp();
}
GenericArgumentsDTO.Add(baseTypeMetadata);
}
TypeMetadataDTO.GenericArguments = GenericArgumentsDTO;
}
//TypeMetadataDTO.Modifiers = new Tuple<AccessLevel, SealedEnum, AbstractEnum>(m_Modifiers.Item1, m_Modifiers.Item2, m_Modifiers.Item3);
if (m_ImplementedInterfaces != null)
{
List <BaseTypeMetadata> ImplementedInterfacesDTO = new List <BaseTypeMetadata>();
foreach (TypeMetadata metadata in m_ImplementedInterfaces)
{
BaseTypeMetadata baseTypeMetadata;
if (BaseTypeMetadata.TypeDictionary.ContainsKey(metadata.m_typeName))
{
baseTypeMetadata = BaseTypeMetadata.TypeDictionary[metadata.m_typeName];
}
else
{
baseTypeMetadata = metadata.MapUp();
}
ImplementedInterfacesDTO.Add(baseTypeMetadata);
}
TypeMetadataDTO.ImplementedInterfaces = ImplementedInterfacesDTO;
}
if (m_NestedTypes != null)
{
List <BaseTypeMetadata> NestedTypeDTO = new List <BaseTypeMetadata>();
foreach (TypeMetadata metadata in m_NestedTypes)
{
BaseTypeMetadata baseTypeMetadata;
if (BaseTypeMetadata.TypeDictionary.ContainsKey(metadata.m_typeName))
{
baseTypeMetadata = BaseTypeMetadata.TypeDictionary[metadata.m_typeName];
}
else
{
baseTypeMetadata = metadata.MapUp();
}
NestedTypeDTO.Add(baseTypeMetadata);
}
TypeMetadataDTO.NestedTypes = NestedTypeDTO;
}
if (m_Properties != null)
{
List <BasePropertyMetadata> PropertiesDTO = new List <BasePropertyMetadata>();
foreach (PropertyMetadata metadata in m_Properties)
{
BasePropertyMetadata propertyMetadata = metadata.MapUp();
PropertiesDTO.Add(propertyMetadata);
}
TypeMetadataDTO.Properties = PropertiesDTO;
}
if (m_DeclaringType != null)
{
if (BaseTypeMetadata.TypeDictionary.ContainsKey(m_DeclaringType.m_typeName))
{
TypeMetadataDTO.DeclaringType = BaseTypeMetadata.TypeDictionary[m_DeclaringType.m_typeName];
}
else
{
TypeMetadataDTO.DeclaringType = m_DeclaringType.MapUp();
}
}
if (m_Methods != null)
{
List <BaseMethodMetadata> MethodMetadataDTO = new List <BaseMethodMetadata>();
foreach (MethodMetadata metadata in m_Methods)
{
BaseMethodMetadata methodMetadata = metadata.MapUp();
MethodMetadataDTO.Add(methodMetadata);
}
TypeMetadataDTO.Methods = MethodMetadataDTO;
}
if (m_Constructors != null)
{
List <BaseMethodMetadata> ConstructorsDTO = new List <BaseMethodMetadata>();
foreach (MethodMetadata metadata in m_Methods)
{
BaseMethodMetadata methodMetadata = metadata.MapUp();
ConstructorsDTO.Add(methodMetadata);
}
TypeMetadataDTO.Constructors = ConstructorsDTO;
}
if (!BaseTypeMetadata.TypeDictionary.ContainsKey(TypeMetadataDTO.TypeName))
{
BaseTypeMetadata.TypeDictionary.Add(TypeMetadataDTO.TypeName, TypeMetadataDTO);
}
TypeMetadataDTO.TypeKind = m_TypeKind;
return(TypeMetadataDTO);
}
