public TypeMetadata(ITypeMetadata typeMetadata)
{
Name = typeMetadata.Name;
SavedHash = typeMetadata.SavedHash;
NamespaceName = typeMetadata.NamespaceName;
// Base type
if (typeMetadata.BaseType is null)
{
BaseType = null;
}
else if (AlreadyMapped.TryGetValue(typeMetadata.BaseType.SavedHash, out IMetadata item))
{
BaseType = item as ITypeMetadata;
}
else
{
BaseType = new TypeMetadata(typeMetadata.BaseType.SavedHash, typeMetadata.BaseType.Name);
}
// Generic Arguments
if (typeMetadata.GenericArguments is null)
{
GenericArguments = null;
}
else
{
List <ITypeMetadata> genericArguments = new List <ITypeMetadata>();
foreach (ITypeMetadata genericArgument in typeMetadata.GenericArguments)
{
if (AlreadyMapped.TryGetValue(genericArgument.SavedHash, out IMetadata item))
{
genericArguments.Add(item as ITypeMetadata);
}
else
{
genericArguments.Add(new TypeMetadata(genericArgument.SavedHash, genericArgument.Name));
}
}
GenericArguments = genericArguments;
}
// Modifiers
Modifiers = typeMetadata.Modifiers;
// Type kind
TypeKind = typeMetadata.TypeKind;
// Attributes
if (typeMetadata.Attributes is null)
{
Attributes = Enumerable.Empty <IAttributeMetadata>();
}
else
{
List <IAttributeMetadata> attributes = new List <IAttributeMetadata>();
foreach (IAttributeMetadata attribute in typeMetadata.Attributes)
{
if (AlreadyMapped.TryGetValue(attribute.SavedHash, out IMetadata item))
{
attributes.Add(item as IAttributeMetadata);
}
else
{
IAttributeMetadata newAttribute = new AttributeMetadata(attribute);
attributes.Add(newAttribute);
AlreadyMapped.Add(newAttribute.SavedHash, newAttribute);
}
}
Attributes = attributes;
}
// Interfaces
if (typeMetadata.ImplementedInterfaces is null)
{
ImplementedInterfaces = Enumerable.Empty <ITypeMetadata>();
}
else
{
List <ITypeMetadata> interfaces = new List <ITypeMetadata>();
foreach (ITypeMetadata implementedInterface in typeMetadata.ImplementedInterfaces)
{
if (AlreadyMapped.TryGetValue(implementedInterface.SavedHash, out IMetadata item))
{
interfaces.Add(item as ITypeMetadata);
}
else
{
interfaces.Add(new TypeMetadata(implementedInterface.SavedHash, implementedInterface.Name));
}
}
ImplementedInterfaces = interfaces;
}
// Nested Types
if (typeMetadata.NestedTypes is null)
{
NestedTypes = null;
}
else
{
List <ITypeMetadata> nestedTypes = new List <ITypeMetadata>();
foreach (ITypeMetadata nestedType in typeMetadata.NestedTypes)
{
if (AlreadyMapped.TryGetValue(nestedType.SavedHash, out IMetadata item))
{
nestedTypes.Add(item as ITypeMetadata);
}
else
{
nestedTypes.Add(new TypeMetadata(nestedType.SavedHash, nestedType.Name));
}
}
NestedTypes = nestedTypes;
}
// Properties
if (typeMetadata.Properties is null)
{
Properties = Enumerable.Empty <IPropertyMetadata>();
}
else
{
List <IPropertyMetadata> properties = new List <IPropertyMetadata>();
foreach (IPropertyMetadata property in typeMetadata.Properties)
{
if (AlreadyMapped.TryGetValue(property.SavedHash, out IMetadata item))
{
properties.Add(item as IPropertyMetadata);
}
else
{
IPropertyMetadata newProperty = new PropertyMetadata(property);
properties.Add(newProperty);
AlreadyMapped.Add(newProperty.SavedHash, newProperty);
}
}
Properties = properties;
}
//Declaring type
if (typeMetadata.DeclaringType is null)
{
DeclaringType = null;
}
else if (AlreadyMapped.TryGetValue(typeMetadata.DeclaringType.SavedHash, out IMetadata item))
{
DeclaringType = item as ITypeMetadata;
}
else
{
DeclaringType = new TypeMetadata(typeMetadata.DeclaringType.SavedHash, typeMetadata.DeclaringType.Name);
}
// Methods
if (typeMetadata.Methods is null)
{
Methods = Enumerable.Empty <IMethodMetadata>();
}
else
{
List <IMethodMetadata> methods = new List <IMethodMetadata>();
foreach (IMethodMetadata method in typeMetadata.Methods)
{
if (AlreadyMapped.TryGetValue(method.SavedHash, out IMetadata item))
{
methods.Add(item as IMethodMetadata);
}
else
{
IMethodMetadata newMethod = new MethodMetadata(method);
methods.Add(newMethod);
AlreadyMapped.Add(newMethod.SavedHash, newMethod);
}
}
Methods = methods;
}
// Constructors
if (typeMetadata.Methods is null)
{
Constructors = Enumerable.Empty <IMethodMetadata>();
}
else
{
List <IMethodMetadata> constructors = new List <IMethodMetadata>();
foreach (IMethodMetadata constructor in typeMetadata.Methods)
{
if (AlreadyMapped.TryGetValue(constructor.SavedHash, out IMetadata item))
{
constructors.Add(item as IMethodMetadata);
}
else
{
IMethodMetadata newMethod = new MethodMetadata(constructor);
constructors.Add(newMethod);
AlreadyMapped.Add(newMethod.SavedHash, newMethod);
}
}
Constructors = constructors;
}
FillChildren(new StreamingContext());
}