/// <summary>
/// Creates a code type reference for the given type
/// </summary>
/// <param name="type">The given system type for which to generate a type reference</param>
/// <param name="parameters">The type arguments</param>
/// <returns>A code reference with namespace set accordingly</returns>
public static CodeTypeReference ToTypeReference(this Type type, params CodeTypeReference[] parameters)
{
var reference = new CodeTypeReference(type.Name, parameters);
reference.SetNamespace(type.Namespace);
return(reference);
}
/// <summary>
/// Creates a code type reference for the given type
/// </summary>
/// <param name="type">The given system type for which to generate a type reference</param>
/// <returns>A code reference with namespace set accordingly</returns>
public static CodeTypeReference ToTypeReference(this Type type)
{
var reference = new CodeTypeReference(type.Name);
reference.SetNamespace(type.Namespace);
return(reference);
}
protected virtual void ResolveMultipleInheritanceMembers(CodeTypeDeclaration generatedType, HashSet <CodeTypeMember> shadows, CodeConstructor constructor)
{
Func <CodeTypeDeclaration, IEnumerable <CodeTypeDeclaration> > getBaseTypes =
type => {
var interfaceType = CodeDomHelper.GetOrCreateUserItem <CodeTypeDeclaration>(type, CodeDomHelper.InterfaceKey);
if (interfaceType == null)
{
interfaceType = type;
}
return(interfaceType.BaseTypes.Cast <CodeTypeReference>().Select(r => r.GetTypeForReference()).Where(c => c != null));
};
var layering = Layering <CodeTypeDeclaration> .CreateLayers(generatedType, getBaseTypes);
CodeTypeDeclaration implBaseType = FindBaseClassAndCreateShadows(generatedType, shadows, layering);
IEnumerable <CodeTypeDeclaration> inheritedBaseClasses;
if (implBaseType != null)
{
inheritedBaseClasses = implBaseType.Closure(getBaseTypes);
var implementationRef = new CodeTypeReference();
implementationRef.BaseType = implBaseType.Name;
var n = implBaseType.GetReferenceForType().Namespace();
if (n != null && n.EndsWith(implBaseType.Name))
{
implementationRef.BaseType = n + "." + implBaseType.Name;
}
else
{
implementationRef.SetNamespace(n);
}
generatedType.BaseTypes.Insert(0, implementationRef);
}
else
{
inheritedBaseClasses = Enumerable.Empty <CodeTypeDeclaration>();
AddImplementationBaseClass(generatedType);
}
for (int i = layering.Count - 1; i >= 0; i--)
{
foreach (var baseType in layering[i])
{
if (!inheritedBaseClasses.Contains(baseType) &&
baseType != generatedType &&
ShouldContainMembers(generatedType, baseType.GetReferenceForType()))
{
var dependent = baseType.DependentMembers(false);
if (dependent != null)
{
foreach (var inheritedMember in dependent)
{
RecursivelyAddDependentMembers(generatedType.Members, constructor.Statements, inheritedMember, shadows);
}
}
}
}
}
}
/// <summary>
/// Creates a reference to the given NMeta type
/// </summary>
/// <param name="type">The NMeta type</param>
/// <param name="isReference">A value indicating whether to default to IModelElement or object</param>
/// <param name="context">The transformation context</param>
/// <returns>A code type reference</returns>
protected static CodeTypeReference CreateReference(IType type, bool isReference, ITransformationContext context, bool implementation = false)
{
if (type != null)
{
var mappedType = type.GetExtension <MappedType>();
if (mappedType != null)
{
var reference = new CodeTypeReference();
if (mappedType.SystemType.IsValueType || mappedType.SystemType == typeof(string))
{
reference.BaseType = mappedType.SystemType.FullName;
}
else
{
reference.BaseType = mappedType.SystemType.Name;
if (typeof(IModelElement).IsAssignableFrom(mappedType.SystemType) && implementation)
{
reference.BaseType = reference.BaseType.Substring(1);
}
reference.SetNamespace(mappedType.SystemType.Namespace);
}
return(reference);
}
var declaration = context.Trace.ResolveIn((Type2Type)context.Transformation.GetRuleForRuleType(typeof(Type2Type)), type);
if (declaration != null)
{
if (!implementation)
{
return(CodeDomHelper.GetReferenceForType(declaration));
}
else
{
var reference = new CodeTypeReference();
reference.SetNamespace(CodeDomHelper.GetReferenceForType(declaration).Namespace());
reference.BaseType = declaration.Name;
return(reference);
}
}
}
var primitiveType = type as IPrimitiveType;
if (primitiveType != null)
{
return(new CodeTypeReference(primitiveType.SystemType));
}
if (isReference)
{
return(typeof(IModelElement).ToTypeReference());
}
else
{
return(new CodeTypeReference(typeof(object)));
}
}
/// <summary>
/// Creates a code type reference for the given type
/// </summary>
/// <param name="type">The given system type for which to generate a type reference</param>
/// <returns>A code reference with namespace set accordingly</returns>
public static CodeTypeReference ToTypeReference(this Type type)
{
var reference = new CodeTypeReference(type.Name);
reference.SetNamespace(type.Namespace);
if (type.IsGenericType)
{
foreach (var typePar in type.GetGenericArguments())
{
reference.TypeArguments.Add(typePar.ToTypeReference());
}
}
return(reference);
}
protected virtual void ResolveMultipleInheritanceMembers(CodeTypeDeclaration generatedType, HashSet <CodeTypeMember> shadows, CodeConstructor constructor)
{
var allClasses = generatedType.Closure(GetBaseClasses);
var layering = Layering <CodeTypeDeclaration> .CreateLayers(generatedType, c => Edges(c, allClasses));
CodeTypeDeclaration implBaseType = null;
int layerIndex;
for (layerIndex = layering.Count - 1; layerIndex >= 0; layerIndex--)
{
var layer = layering[layerIndex];
if (layer.Count == 1 && layer.First() != generatedType && !shadows.IntersectsWith(AllFeatures(layer.First())))
{
implBaseType = layer.First();
break;
}
foreach (var cl in layer)
{
shadows.UnionWith(Refinements(cl));
}
}
IEnumerable <CodeTypeDeclaration> inheritedBaseClasses;
if (implBaseType != null)
{
inheritedBaseClasses = layering.Take(layerIndex + 1).SelectMany(s => s);
var implementationRef = new CodeTypeReference();
implementationRef.BaseType = implBaseType.Name;
var n = implBaseType.GetReferenceForType().Namespace();
if (n != null && n.EndsWith(implBaseType.Name))
{
implementationRef.BaseType = n + "." + implBaseType.Name;
}
else
{
implementationRef.SetNamespace(n);
}
generatedType.BaseTypes.Insert(0, implementationRef);
}
else
{
inheritedBaseClasses = Enumerable.Empty <CodeTypeDeclaration>();
AddImplementationBaseClass(generatedType);
}
CodeDomHelper.SetUserItem(generatedType, CodeDomHelper.BaseClassesKey, inheritedBaseClasses);
for (int i = layerIndex + 1; i < layering.Count; i++)
{
foreach (var baseType in layering[i])
{
if (baseType != generatedType)
{
var dependent = baseType.DependentMembers(false);
if (dependent != null)
{
foreach (var inheritedMember in dependent)
{
RecursivelyAddDependentMembers(generatedType.Members, constructor.Statements, inheritedMember, shadows);
}
}
}
}
}
}