public XMLMethodModel(BaseMethodMetadata methodBase)
{
MethodName = methodBase.MethodName;
Extension = methodBase.Extension;
ReturnType = XMLTypeModel.GetOrAdd(methodBase.ReturnType);
Modifiers = new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(methodBase.Modifiers.Item1, methodBase.Modifiers.Item2, methodBase.Modifiers.Item3, methodBase.Modifiers.Item4);
GenericArguments = methodBase.GenericArguments?.Select(g => XMLTypeModel.GetOrAdd(g));
Parameters = methodBase.Parameters?.Select(p => new XMLParameterModel(p));
}
private static DBTypeModel EmitReturnTypeDatabase(BaseMethodMetadata method)
{
BaseMethodMetadata methodInfo = method as BaseMethodMetadata;
if (methodInfo == null)
{
return(null);
}
return(DBTypeMapper.EmitReferenceDatabase(methodInfo.ReturnType));
}
public static BaseMethodMetadata MapToBase(DBMethodModel methodMetadata)
{
BaseMethodMetadata methodModel = new BaseMethodMetadata
{
MethodName = methodMetadata.Name,
GenericArguments = DBTypeMapper.EmitGenericArgumentsDTG(methodMetadata.GenericArgumentsL),
ReturnType = EmitReturnTypeDTG(methodMetadata),
Parameters = EmitParametersDTG(methodMetadata.ParametersL),
};
return(methodModel);
}
public static DBMethodModel MapToDB(BaseMethodMetadata methodMetadata)
{
DBMethodModel methodModel = new DBMethodModel
{
Name = methodMetadata.MethodName,
GenericArguments = DBTypeMapper.EmitGenericArgumentsDatabase(methodMetadata.GenericArguments),
ReturnType = EmitReturnTypeDatabase(methodMetadata),
Parameters = EmitParametersDatabase(methodMetadata.Parameters),
};
return(methodModel);
}
public MethodMetadata(BaseMethodMetadata methodMetadata)
{
m_Name = methodMetadata.MethodName;
if (methodMetadata.GenericArguments != null)
{
List <TypeMetadata> genericArguments = new List <TypeMetadata>();
foreach (BaseTypeMetadata baseMetadata in methodMetadata.GenericArguments)
{
TypeMetadata metadata;
if (TypeMetadata.m_typesMetadata.ContainsKey(baseMetadata.TypeName))
{
metadata = TypeMetadata.m_typesMetadata[baseMetadata.TypeName];
}
else
{
metadata = new TypeMetadata(baseMetadata);
}
genericArguments.Add(metadata);
}
m_GenericArguments = genericArguments;
}
if (methodMetadata.ReturnType != null)
{
if (TypeMetadata.m_typesMetadata.ContainsKey(methodMetadata.ReturnType.TypeName))
{
m_ReturnType = TypeMetadata.m_typesMetadata[methodMetadata.ReturnType.TypeName];
}
else
{
m_ReturnType = new TypeMetadata(methodMetadata.ReturnType);
}
}
m_Extension = methodMetadata.Extension;
if (methodMetadata.Parameters != null)
{
List <ParameterMetadata> parameters = new List <ParameterMetadata>();
foreach (BaseParameterMetadata baseMetadata in methodMetadata.Parameters)
{
ParameterMetadata metadata = new ParameterMetadata(baseMetadata);
parameters.Add(metadata);
}
m_Parameters = parameters;
}
m_Modifiers = methodMetadata.Modifiers;
}
public BaseMethodMetadata MapUp()
{
BaseMethodMetadata MethodMetadataDTO = new BaseMethodMetadata();
MethodMetadataDTO.MethodName = m_Name;
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);
}
MethodMetadataDTO.GenericArguments = GenericArgumentsDTO;
}
MethodMetadataDTO.Modifiers = new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(m_Modifiers.Item1, m_Modifiers.Item2, m_Modifiers.Item3, m_Modifiers.Item4);
if (m_ReturnType != null)
{
if (BaseTypeMetadata.TypeDictionary.ContainsKey(m_ReturnType.m_typeName))
{
MethodMetadataDTO.ReturnType = BaseTypeMetadata.TypeDictionary[m_ReturnType.m_typeName];
}
else
{
MethodMetadataDTO.ReturnType = m_ReturnType.MapUp();
}
}
MethodMetadataDTO.Extension = m_Extension;
if (m_Parameters != null)
{
List <BaseParameterMetadata> ParameterDTO = new List <BaseParameterMetadata>();
foreach (ParameterMetadata metadata in m_Parameters)
{
BaseParameterMetadata baseParameterMetadata = metadata.MapUp();
ParameterDTO.Add(baseParameterMetadata);
}
MethodMetadataDTO.Parameters = ParameterDTO;
}
return(MethodMetadataDTO);
}
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 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);
}
