private TypeMetadataDto LoadGenericParameterTypeObject(Type type, AssemblyMetadataStorage metaStore)
{
TypeMetadataDto metadataType;
string id = $"{type.DeclaringType.FullName}<{type.Name}>";
_logger.Trace("Adding generic argument type with Id =" + id);
if (!metaStore.TypesDictionary.ContainsKey(id))
{
metadataType = new TypeMetadataDto()
{
Id = id,
TypeName = type.Name,
NamespaceName = type.Namespace,
Modifiers = null,
TypeKind = GetTypeKind(type),
Attributes = new List <Attribute>(),
Properties = new List <PropertyMetadataDto>(),
Constructors = new List <MethodMetadataDto>(),
ImplementedInterfaces = new List <TypeMetadataDto>(),
Methods = new List <MethodMetadataDto>(),
NestedTypes = new List <TypeMetadataDto>(),
GenericArguments = new List <TypeMetadataDto>()
};
metaStore.TypesDictionary.Add(metadataType.Id, metadataType);
return(metadataType);
}
else
{
return(metaStore.TypesDictionary[id]);
}
}
protected void With_TypeMetaData()
{
NamespaceMetadataDto namespaceMetadata = _storage.NamespacesDictionary[_namespaceName];
TypeMetadataDto typeMetadata = CreateSimpleTypeMetadata(_typeName);
(namespaceMetadata.Types as List <TypeMetadataDto>).Add(typeMetadata);
_storage.TypesDictionary.Add(typeMetadata.Id, typeMetadata);
}
// TODO: handle attributes impact on visibility
private MetadataItem MapItem(TypeMetadataDto objectToMap)
{
return(new MetadataItem(
$"{objectToMap.TypeKind.ToString().Replace("Type", string.Empty)}: {objectToMap.TypeName}",
objectToMap.BaseType != null ||
objectToMap.DeclaringType != null ||
objectToMap.Constructors?.Any() == true ||
objectToMap.Methods?.Any() == true ||
objectToMap.GenericArguments?.Any() == true ||
objectToMap.ImplementedInterfaces?.Any() == true ||
objectToMap.NestedTypes?.Any() == true ||
objectToMap.Properties?.Any() == true));
}
protected void With_PropertyMetadata()
{
TypeMetadataDto typeMetadata = _storage.TypesDictionary[_typeName];
typeMetadata.TypeKind = TypeKind.ClassType;
TypeMetadataDto propertyTypeMetadata = CreateSimpleTypeMetadata(_secondTypeName);
PropertyMetadataDto propertyMetadata = new PropertyMetadataDto()
{
Id = _propertyName,
Name = _propertyName,
TypeMetadata = propertyTypeMetadata
};
(typeMetadata.Properties as List <PropertyMetadataDto>).Add(propertyMetadata);
_storage.PropertiesDictionary.Add(propertyMetadata.Id, propertyMetadata);
_storage.TypesDictionary.Add(propertyTypeMetadata.Id, propertyTypeMetadata);
}
private IEnumerable <Relation> GetRelations(TypeMetadataDto value)
{
foreach (var item in value.Constructors)
{
yield return(new Relation(value.Id, item.Id));
}
foreach (var item in value.Methods)
{
yield return(new Relation(value.Id, item.Id));
}
foreach (var item in value.Properties)
{
yield return(new Relation(value.Id, item.Id));
}
// foreach (var item in value.Attributes)
// {
// yield return new Relation(value.Id, );
// }
// TODO check attributes
foreach (var item in value.GenericArguments)
{
yield return(new Relation(value.Id, item.Id));
}
foreach (var item in value.ImplementedInterfaces)
{
yield return(new Relation(value.Id, item.Id));
}
foreach (var item in value.NestedTypes)
{
yield return(new Relation(value.Id, item.Id));
}
}
protected void With_VoidMethodMetadata(IEnumerable <ParameterMetadataDto> parameters)
{
TypeMetadataDto typeMetadata = _storage.TypesDictionary[_typeName];
typeMetadata.TypeKind = TypeKind.ClassType;
MethodMetadataDto methodMetadata = new MethodMetadataDto()
{
Id = _methodName,
Name = _methodName,
GenericArguments = new List <TypeMetadataDto>(),
Modifiers = new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(
_methodAccessLevel,
default(AbstractEnum),
default(StaticEnum),
default(VirtualEnum)),
ReturnType = null,
Parameters = parameters
};
(typeMetadata.Methods as List <MethodMetadataDto>).Add(methodMetadata);
_storage.MethodsDictionary.Add(methodMetadata.Id, methodMetadata);
}
private TypeMetadataDto LoadFullTypeObject(Type type, AssemblyMetadataStorage metaStore)
{
TypeMetadataDto metadataType = new TypeMetadataDto()
{
Id = type.FullName,
TypeName = type.Name,
NamespaceName = type.Namespace,
Modifiers = EmitModifiers(type),
TypeKind = GetTypeKind(type),
Attributes = type.GetCustomAttributes(false).Cast <Attribute>()
};
_logger.Trace("Adding type: Id =" + metadataType.Id + " ; Name = " + metadataType.TypeName);
metaStore.TypesDictionary.Add(type.FullName, metadataType);
metadataType.DeclaringType = EmitDeclaringType(type.DeclaringType, metaStore);
metadataType.ImplementedInterfaces = EmitImplements(type.GetInterfaces(), metaStore);
metadataType.BaseType = EmitExtends(type.BaseType, metaStore);
metadataType.NestedTypes = EmitNestedTypes(type.GetNestedTypes(), metaStore);
if (type.IsGenericTypeDefinition)
{
metadataType.GenericArguments = EmitGenericArguments(type.GetGenericArguments(), metaStore);
metadataType.TypeName =
$"{type.Name}<{metadataType.GenericArguments.Select(a => a.TypeName).Aggregate((p, n) => $"{p}, {n}")}>";
}
else
{
metadataType.GenericArguments = new List <TypeMetadataDto>();
}
metadataType.Constructors = EmitMethods(type.GetConstructors(), metaStore);
metadataType.Methods = EmitMethods(type.GetMethods(BindingFlags.DeclaredOnly), metaStore);
metadataType.Properties = EmitProperties(type.GetProperties(), metaStore);
return(metadataType);
}
public ParameterMetadataDto(string name, TypeMetadataDto typeMetadataDto)
{
Name = name;
TypeMetadata = typeMetadataDto;
}
