private TypeMetadata(TypeBase baseType)
{
if (!storedTypes.ContainsKey(baseType.typeName))
{
storedTypes.Add(baseType.typeName, this);
}
m_typeName = baseType.typeName;
m_NamespaceName = baseType.namespaceName;
m_TypeKind = baseType.typeKind.ToLogicEnum();
m_BaseType = GetOrAdd(baseType.baseType);
m_DeclaringType = GetOrAdd(baseType.declaringType);
m_Modifiers = new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(
baseType.modifiers.Item1.ToLogicEnum(),
baseType.modifiers.Item2.ToLogicEnum(),
baseType.modifiers.Item3.ToLogicEnum());
m_Constructors = baseType.constructors?.Select(c => new MethodMetadata(c));
m_Fields = baseType.fields?.Select(t => new ParameterMetadata(t));
m_GenericArguments = baseType.genericArguments?.Select(GetOrAdd);
m_ImplementedInterfaces = baseType.implementedInterfaces?.Select(GetOrAdd);
m_Methods = baseType.methods?.Select(t => new MethodMetadata(t));
m_NestedTypes = baseType.nestedTypes?.Select(GetOrAdd);
m_Properties = baseType.properties?.Select(t => new PropertyMetadata(t));
}
public static string TypeKindToString(TypeKindEnum typeKind)
{
if (typeKind == TypeKindEnum.ClassType)
{
return("class");
}
else if (typeKind == TypeKindEnum.EnumType)
{
return("enum");
}
else if (typeKind == TypeKindEnum.InterfaceType)
{
return("interface");
}
else
{
return("struct");
}
}
internal static Enums.TypeKindEnum ToLogicEnum(this TypeKindEnum baseEnum)
{
switch (baseEnum)
{
case TypeKindEnum.ClassType:
return(Enums.TypeKindEnum.ClassType);
case TypeKindEnum.EnumType:
return(Enums.TypeKindEnum.EnumType);
case TypeKindEnum.InterfaceType:
return(Enums.TypeKindEnum.InterfaceType);
case TypeKindEnum.StructType:
return(Enums.TypeKindEnum.StructType);
default:
throw new Exception();
}
}
public TypeMetadata(Type type)
{
if (!storedTypes.ContainsKey(type.Name))
{
storedTypes.Add(type.Name, this);
}
m_NamespaceName = type.Namespace;
m_typeName = type.Name;
m_DeclaringType = EmitDeclaringType(type.DeclaringType);
m_Constructors = MethodMetadata.EmitMethods(type.GetConstructors());
m_Methods = MethodMetadata.EmitMethods(type.GetMethods());
m_NestedTypes = EmitNestedTypes(type.GetNestedTypes());
m_ImplementedInterfaces = EmitImplements(type.GetInterfaces());
m_GenericArguments = !type.IsGenericTypeDefinition ? null : TypeMetadata.EmitGenericArguments(type.GetGenericArguments());
m_Modifiers = EmitModifiers(type);
m_BaseType = EmitExtends(type.BaseType);
m_Properties = PropertyMetadata.EmitProperties(type.GetProperties());
m_TypeKind = GetTypeKind(type);
m_Attributes = type.GetCustomAttributes(false).Cast <Attribute>();
m_Fields = EmitFields(type.GetFields());
}
