/// <summary> /// Returns additional required ObjC import directives. /// </summary> /// <param name="facet"></param> /// <returns></returns> public List <string> ObjCImportDirectives(CodeFacet facet, bool filter = true) { List <string> imports = new List <string>(); if (!Config.GenerateFacetBinding(facet)) { return(imports); } // objC type // note that a constructor has no return type string objCType = facet.ObjCFacet.Type; string importStr = null; if (!string.IsNullOrEmpty(objCType)) { // we only need to import types defined in the current assembly. // other types will be imported via their own assembly's header if (AssemblyFacet.DefinesFacetType(facet.Type)) { // if the type is an enum if (facet.IsEnum) { objCType = facet.ObjCFacet.Type; importStr = $"#import \"{objCType}.h\""; imports.Add(importStr); } } } // forward declare objC facet types for all children List <CodeFacet> children = facet.Children(); foreach (CodeFacet child in children) { imports.AddRange(ObjCImportDirectives(child, false)); } // remove duplicates imports = imports.Distinct().ToList(); imports.Sort(); // the filter ensures that the import list doesn't include // the header that the import directives will be inserted into if (filter && importStr != null) { imports.Remove(importStr); } return(imports); }
/// <summary> /// Returns all ObjC import directives required to fully derive an ObjC class from its subclass and its adopted protocols. /// These directives constitute the minimum required to define a class in an ObjC interface header file. /// </summary> /// <param name="facet">Facet</param> /// <returns>List of ObjC import directives.</returns> public List <string> ObjCDerivationImportDirectives(CodeFacet facet) { List <string> imports = new List <string>(); // iterate over the sub facets required to derive the native representation List <CodeFacet> derivation = facet.Derivation(); foreach (CodeFacet cursor in derivation) { string objCType = null; // Managed interfaces don't derive from a base type but from other interfaces (see GetInterfaces) // https://msdn.microsoft.com/en-us/library/system.type.basetype(v=vs.110).aspx // However, our native implementation of the managed interface is a class of System.Object. if (cursor.GetType() == typeof(InterfaceFacet)) { if (AssemblyFacet.DefinesFacetType("System.Object")) { objCType = "System_Object"; imports.Add($"#import \"{objCType}.h\""); } } // for all interfaces we require to import a protocol if (cursor.GetType() == typeof(ImplementedInterfaceFacet) || cursor.GetType() == typeof(InterfaceFacet)) { if (!AssemblyFacet.DefinesFacetType(cursor.Type)) { continue; } // if this interface type is not required then just skip it. // this means that some of the interface methods etc may be represented // and others may not depending on the type exclusion settings if (!Config.GenerateFacetBinding(cursor)) { continue; } objCType = cursor.ObjCFacet.Type; imports.Add($"#import \"{objCType}_Protocol.h\""); } // use base type else { string baseType = cursor.BaseType; // System.Object has no base type if (baseType == null) { continue; } // Derived import directives will only be required for types // defined in the target assembly. If this is not the case // then the required import will have to be defined elsewhere, // most likely in a framework header. if (!AssemblyFacet.DefinesFacetType(baseType)) { continue; } // if we are not generating bindings for the given type then // a header file won't be available string importPrefix = ""; string importSuffix = ""; if (!Config.GenerateTypeBinding(baseType)) { importPrefix = "//"; importSuffix = " // class base defaults to System.Object"; } objCType = cursor.ObjCFacet.BaseType; imports.Add($"{importPrefix}#import \"{objCType}.h\"{importSuffix}"); } } // return a distinct list to remove duplicates imports = imports.Distinct().ToList(); imports.Sort(); return(imports); }