/// <summary>
/// Returns <c>true</c> if the given type represents an unsafe pointer.
/// </summary>
/// <param name="type">The type to check.</param>
/// <returns><c>true</c> if the given type represents an unsafe pointer.</returns>
private bool IsUnsafePointer(NRTypeUsage type)
{
if (type != null && type.FullName != null && type.FullName.Contains("*"))
{
UnsafeTypesPresent = true;
return(true);
}
return(false);
}
/// <summary>
/// Returns <c>true</c> if the given type represents an unsafe pointer.
/// </summary>
/// <param name="type">The type to check.</param>
/// <returns><c>true</c> if the given type represents an unsafe pointer.</returns>
private bool IsUnsafePointer(NRTypeUsage type)
{
if (type.Name.Contains("*"))
{
UnsafeTypesPresent = true;
return true;
}
return false;
}
/// <summary>
/// Gets the <see cref="NRTypeUsage" /> as a C# string.
/// </summary>
/// <param name="typeUsage">The type to get the code for.</param>
/// <returns>A string representing the type.</returns>
public static string Declaration(this NRTypeUsage typeUsage)
{
StringBuilder result = new StringBuilder( );
if (typeUsage.IsDynamic)
{
result.Append("dynamic");
}
else
{
string typeName = typeUsage.FullName;
if ((typeName != null) && typeName.EndsWith("&"))
{
typeName = typeName.Substring(0, typeName.Length - 1);
}
if ((typeName != null) && TypeReplacement.ContainsKey(typeName))
{
result.Append(TypeReplacement[typeName]);
}
else
{
result.Append(string.IsNullOrWhiteSpace(typeUsage.Namespace) || !UseNamespaces || ((KnownNamespaces != null) && KnownNamespaces.Contains(typeUsage.Namespace)) ? "" : typeUsage.Namespace + ".");
result.Append(GetDeclaringTypes(typeUsage.DeclaringType));
result.Append(typeUsage.Name);
}
if (typeUsage.GenericParameters.Count > 0)
{
result.Append("<");
foreach (NRTypeUsage genericParameter in typeUsage.GenericParameters)
{
result.AppendFormat("{0}, ", genericParameter.Declaration( ));
}
result.Length -= 2;
result.Append(">");
}
if (typeUsage.IsNullable)
{
result.Append("?");
}
}
if (typeUsage.IsArray)
{
foreach (int arrayRank in typeUsage.ArrayRanks)
{
result.Append("[");
for (int i = 1; i < arrayRank; i++)
{
result.Append(",");
}
result.Append("]");
}
}
return(result.ToString( ));
}
/// <summary>
/// Returns <c>true</c> if the given type usage uses deep generic nesting.
/// </summary>
/// <param name="nrTypeUsage">The type usage to check.</param>
/// <param name="level">The current level of nesting.</param>
/// <returns><c>true</c> if the given type usage uses deep generic nesting.</returns>
private bool IsDeepGenericNesting(NRTypeUsage nrTypeUsage, int level = 0)
{
if (nrTypeUsage.GenericParameters.Any(genericParameter => IsDeepGenericNesting(genericParameter, level + 1)))
{
return(true);
}
if (level > 2)
{
DeepGenericNestingPresent = true;
return(true);
}
return(false);
}
/// <summary>
/// Returns <c>true</c> if the given type usage contains a nullable generic parameter.
/// </summary>
/// <param name="nrTypeUsage">The type usage to check.</param>
/// <returns><c>true</c> if the given type usage contains a nullable generic parameter.</returns>
private bool IsNullableTypeParameter(NRTypeUsage nrTypeUsage)
{
foreach (NRTypeUsage genericParameter in nrTypeUsage.GenericParameters)
{
if (genericParameter.IsNullable)
{
NullableAsTypeParamPresent = true;
return(true);
}
if (IsNullableTypeParameter(genericParameter))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Returns <c>true</c> if the given type usage is nested within a generic type.
/// </summary>
/// <param name="nrTypeUsage">The type usage to check.</param>
/// <returns><c>true</c> if the given type usage is nested within a generic type.</returns>
private bool IsGenericNested(NRTypeUsage nrTypeUsage)
{
if (nrTypeUsage == null)
{
return(false);
}
NRTypeUsage declaringType = nrTypeUsage.DeclaringType;
while (declaringType != null)
{
if (declaringType.IsGeneric)
{
GenericNestingPresent = true;
return(true);
}
declaringType = declaringType.DeclaringType;
}
return(false);
}
/// <summary>
/// Gets a string representing the C#-Code for the declaring types.
/// </summary>
/// <param name="declaringType">The declaring types of this type usage are returned.</param>
/// <returns>A string representing the C#-Code for the declaring types.</returns>
private static string GetDeclaringTypes(NRTypeUsage declaringType)
{
if (declaringType == null)
{
return("");
}
StringBuilder result = new StringBuilder(GetDeclaringTypes(declaringType.DeclaringType) + declaringType.Name);
if (declaringType.GenericParameters.Count > 0)
{
result.Append("<");
foreach (NRTypeUsage genericParameter in declaringType.GenericParameters)
{
result.AppendFormat("{0}, ", genericParameter.Declaration( ));
}
result.Length -= 2;
result.Append(">");
}
return(result + ".");
}
/// <summary>
/// Visit a <see cref="NRTypeUsage"/>.
/// </summary>
/// <param name="nrTypeUsage">The <see cref="NRTypeUsage"/> to visit.</param>
public void Visit(NRTypeUsage nrTypeUsage)
{
OutputLine("NRTypeUsage");
indent++;
OutputLine("ArrayRanks: " + nrTypeUsage.ArrayRanks.Aggregate("", (first, second) => first + ", " + second));
nrTypeUsage.GenericParameters.ForEach(nrGenericParameter => nrGenericParameter.Accept(this));
OutputLine("IsArray: " + nrTypeUsage.IsArray);
OutputLine("IsDynamic: " + nrTypeUsage.IsDynamic);
OutputLine("IsNullable: " + nrTypeUsage.IsNullable);
OutputLine("Name: " + nrTypeUsage.Name);
OutputLine("Namespace: " + nrTypeUsage.Namespace);
OutputLine("FullName: " + nrTypeUsage.FullName);
if (nrTypeUsage.DeclaringType != null)
{
OutputLine("DeclaringType:");
indent++;
nrTypeUsage.DeclaringType.Accept(this);
indent--;
}
indent--;
}
/// <summary>
/// Returns a readable string containing the <see cref="NRTypeUsage"/>.
/// </summary>
/// <param name="nrTypeUsage">The <see cref="NRTypeUsage"/> to convert to a string.</param>
/// <returns>The converted <see cref="NRTypeUsage"/></returns>
private string ToString(NRTypeUsage nrTypeUsage)
{
if (nrTypeUsage.IsDynamic)
{
return("dynamic");
}
string declaration = "";
if (nrTypeUsage.DeclaringType != null)
{
declaration = ToString(nrTypeUsage.DeclaringType) + ".";
}
declaration += nrTypeUsage.Name;
if (nrTypeUsage.GenericParameters.Count > 0)
{
declaration += "<";
declaration = nrTypeUsage.GenericParameters.Aggregate(declaration, (current, genericParameter) => current + ToString(genericParameter) + ", ");
declaration = declaration.Substring(0, declaration.Length - 2);
declaration += ">";
}
if (nrTypeUsage.IsNullable)
{
declaration += "?";
}
foreach (int arrayRank in nrTypeUsage.ArrayRanks)
{
declaration += "[";
for (int i = 1; i < arrayRank; i++)
{
declaration += ",";
}
declaration += "]";
}
return(declaration);
}
/// <summary>
/// Visit a <see cref="NRTypeUsage"/>.
/// </summary>
/// <param name="nrTypeUsage">The <see cref="NRTypeUsage"/> to visit.</param>
public void Visit(NRTypeUsage nrTypeUsage)
{
// Do nothing
}
public static string ToNClass(this NRTypeUsage type)
{
return(type.Declaration().TrimEnd('&'));
}
/// <summary>
/// Determines if NClass can handle a specific type usage.
/// </summary>
/// <param name="nrTypeUsage">The type usage to check.</param>
/// <returns><c>True</c> if the type usage can be imported to NClass.</returns>
private bool CanImportTypeUsage(NRTypeUsage nrTypeUsage)
{
return(!IsUnsafePointer(nrTypeUsage) && !IsGenericNested(nrTypeUsage) && !IsNullableTypeParameter(nrTypeUsage) && !IsDeepGenericNesting(nrTypeUsage));
}
/// <summary>
/// Visit a <see cref="NRTypeUsage"/>.
/// </summary>
/// <param name="nrTypeUsage">The <see cref="NRTypeUsage"/> to visit.</param>
public void Visit(NRTypeUsage nrTypeUsage)
{
// Don't do anything...
}
