/// <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... }