/** * Returns true if should generate binding for facet * * white list contains System.Threading.Tasks.Task * black list contains System.Runtime.CompilerServices * System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1<System.Threading.Tasks.Task`1+TResult> * * we need to ensure that every component of the constructed type is valid. */ public bool GenerateFacetBinding(CodeFacet facet) { // confirm member binding if (facet.GetType() == typeof(MethodFacet) || facet.GetType() == typeof(PropertyFacet) || facet.GetType() == typeof(FieldFacet)) { // the accessor form for generic types requires that we use the RootType string accessor = CodeFacet.RootType(facet.Parent.Type) + ":" + facet.Name; if (!GenerateMemberBinding(accessor)) { return(false); } } // initial type test string type; if (facet.TypeNamespace != null) { type = facet.TypeNamespace + "." + facet.NameFromType; } else { type = facet.NameFromType; } // hmm... would not be clearer to reference facet.Type in the above if (facet.Type != type) { // we do see warnings here so a bit more investigation is required //Console.WriteLine($"Warning: facet.Type {facet.Type} != {type}"); } if (!GenerateTypeBinding(type)) { return(false); } // generic parameter type tests foreach (string t in facet.GenericArgumentTypes) { if (!GenerateTypeBinding(t)) { return(false); } } return(true); }
public void WriteFacet(CodeFacet facet) { Type ft = facet.GetType(); if (ft == typeof(EnumerationFacet)) { WriteEnumeration((EnumerationFacet)facet); } else if (ft == typeof(InterfaceFacet)) { WriteInterface((InterfaceFacet)facet); // provide access to the properties and methods of an explicit interface WriteInterfaceClass((InterfaceFacet)facet); // for protocol definitions we don't want to overwrite the class header so we append a suffix. facet.OutputFileNameSuffix = ".Protocol"; WriteInterface((InterfaceFacet)facet); facet.OutputFileNameSuffix = ""; } else if (ft == typeof(StructFacet)) { WriteStruct((StructFacet)facet); } else if (ft == typeof(ClassFacet)) { WriteClass((ClassFacet)facet); } }
/// <summary> /// Returns all ObjC forward class and protocol declarations required to fully represent the facet. /// </summary> /// <param name="facet"></param> /// <returns></returns> public List <string> ObjCForwardDeclarations(CodeFacet facet) { 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; if (!string.IsNullOrEmpty(objCType)) { // if the type is a generic parameter if (facet.IsGenericParameterOrRef()) { objCType = "System_Object"; } string import = String.Format("@class {0};", objCType); imports.Add(import); if (facet.IsArray == true) { import = String.Format("@class {0};", facet.ObjCFacet.BaseType); imports.Add(import); } if (facet.GetType() == typeof(InterfaceFacet) || facet.IsInterface) { import = String.Format("@protocol {0}_;", objCType); imports.Add(import); import = String.Format("@protocol {0};", objCType); imports.Add(import); } } // forward declare objC facet types for all children List <CodeFacet> children = facet.Children(); foreach (CodeFacet child in children) { imports.AddRange(ObjCForwardDeclarations(child)); } // return a distinct list to remove duplicates imports = imports.Distinct().ToList(); imports.Sort(); return(imports); }
// // OutputImplementedProtocolSuffix() // // Return a class declaration suffix based on the outputType // string OutputImplementedProtocolSuffix(CodeFacet facet) { string value = ""; if (OutputFileType == OutputType.Interface) { // class or interface facet if (facet is InterfaceFacet) { var interfaceFacet = (InterfaceFacet)facet; IList<ImplementedInterfaceFacet> implementedInterfaces = interfaceFacet.ImplementedInterfaces; if (implementedInterfaces.Count > 0) { // we may wish to naively filter out system interfaces while full // system code generation is pending. // this will hopefully let us usefully represent user implemented interfaces. if (Config.FilterSystemInterfaces) { var interfaces = new List<ImplementedInterfaceFacet>(); foreach ( ImplementedInterfaceFacet implementedInterfaceFacet in implementedInterfaces) { string interfaceType = implementedInterfaceFacet.Type; bool isNaiveSystemType = interfaceType.StartsWith("System.", StringComparison.OrdinalIgnoreCase); if (!isNaiveSystemType) { interfaces.Add(implementedInterfaceFacet); } } implementedInterfaces = interfaces; } if (implementedInterfaces.Count > 0) { // cast IList<CodeFacet> codeFacets = implementedInterfaces.Cast<CodeFacet>().ToList(); // facet is interface facet type? if (facet.GetType() == typeof(InterfaceFacet)) { // insert the interface's own type as we are defining the protocols // that will be used to define a class representing the interface codeFacets.Insert(0, facet); } value = " <"; int i = 0; foreach (CodeFacet codeFacet in codeFacets) { if (i++ > 0) value += ", "; value += ObjCIdentifierFromManagedIdentifier(codeFacet.Type); } value += ">"; } } } } return value; }
// // OutputImplementedProtocolSuffix() // // Return a class declaration suffix based on the outputType // string OutputImplementedProtocolSuffix(CodeFacet facet) { string value = ""; if (OutputFileType == OutputType.Interface) { // class or interface facet if (facet is InterfaceFacet) { var interfaceFacet = (InterfaceFacet)facet; IList <ImplementedInterfaceFacet> implementedInterfaces = interfaceFacet.ImplementedInterfaces; // heed required type binding implementedInterfaces = implementedInterfaces.Where(f => Config.GenerateFacetBinding(f)).ToList(); if (implementedInterfaces.Count > 0) { // we may wish to naively filter out system interfaces while full // system code generation is pending. // this will hopefully let us usefully represent user implemented interfaces. if (Config.FilterSystemInterfaces) { var interfaces = new List <ImplementedInterfaceFacet>(); foreach (ImplementedInterfaceFacet implementedInterfaceFacet in implementedInterfaces) { string interfaceType = implementedInterfaceFacet.Type; bool isNativeSystemType = interfaceType.StartsWith("System.", StringComparison.OrdinalIgnoreCase); if (!isNativeSystemType) { interfaces.Add(implementedInterfaceFacet); } } implementedInterfaces = interfaces; } if (implementedInterfaces.Count > 0) { // cast IList <CodeFacet> codeFacets = implementedInterfaces.Cast <CodeFacet>().ToList(); // facet is interface facet type? if (facet.GetType() == typeof(InterfaceFacet)) { // insert the interface's own type as we are defining the protocols // that will be used to define a class representing the interface codeFacets.Insert(0, facet); } value = " <"; int i = 0; foreach (CodeFacet codeFacet in codeFacets) { if (i++ > 0) { value += ", "; } value += (ObjCIdentifierFromManagedIdentifier(codeFacet.Type) + "_"); } value += ">"; } } } } return(value); }