void AddNestedSiblingTypes(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo genInfo) { // Generate sibling types for nested types we don't want to nest foreach (var nest in iface.NestedTypes.Where(t => t.Unnest)) { pre_sibling_types.Add(SourceWriterExtensions.BuildManagedTypeModel(nest, opt, context, genInfo)); } }
public BoundAbstractProperty(GenBase gen, Property property, CodeGenerationOptions opt) { Name = property.AdjustedName; PropertyType = new TypeReferenceWriter(opt.GetTypeReferenceName(property.Getter.RetVal)); SetVisibility(property.Getter.RetVal.IsGeneric ? "protected" : property.Getter.Visibility); IsAbstract = true; HasGet = true; var baseProp = gen.BaseSymbol != null?gen.BaseSymbol.GetPropertyByName(property.Name, true) : null; if (baseProp != null) { IsOverride = true; } else { IsShadow = gen.RequiresNew(property); getter_callback = new MethodCallback(gen, property.Getter, opt, property.AdjustedName, false); if (property.Setter != null) { setter_callback = new MethodCallback(gen, property.Setter, opt, property.AdjustedName, false); } } if (gen.IsGeneratable) { GetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.MetadataXPathReference}/method[@name='{property.Getter.JavaName}'{property.Getter.Parameters.GetMethodXPathPredicate ()}]\""); } if (property.Getter.IsReturnEnumified) { GetterAttributes.Add(new GeneratedEnumAttr(true)); } SourceWriterExtensions.AddSupportedOSPlatform(GetterAttributes, property.Getter, opt); GetterAttributes.Add(new RegisterAttr(property.Getter.JavaName, property.Getter.JniSignature, property.Getter.GetConnectorNameFull(opt), additionalProperties: property.Getter.AdditionalAttributeString())); SourceWriterExtensions.AddMethodCustomAttributes(GetterAttributes, property.Getter); if (property.Setter != null) { HasSet = true; if (gen.IsGeneratable) { SetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.MetadataXPathReference}/method[@name='{property.Setter.JavaName}'{property.Setter.Parameters.GetMethodXPathPredicate ()}]\""); } SourceWriterExtensions.AddSupportedOSPlatform(SetterAttributes, property.Setter, opt); SourceWriterExtensions.AddMethodCustomAttributes(SetterAttributes, property.Setter); SetterAttributes.Add(new RegisterAttr(property.Setter.JavaName, property.Setter.JniSignature, property.Setter.GetConnectorNameFull(opt), additionalProperties: property.Setter.AdditionalAttributeString())); } }
protected override void WriteSetterBody(CodeWriter writer) { var pname = property.Setter.Parameters [0].Name; property.Setter.Parameters [0].Name = "value"; SourceWriterExtensions.WriteMethodInvokerBody(writer, property.Setter, opt, context_this); property.Setter.Parameters [0].Name = pname; }
void AddNestedTypes(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo genInfo) { // Generate nested types for supported nested types. This is a new addition in C#8. // Prior to this, types nested in an interface had to be generated as sibling types. // The "Unnest" property is used to support backwards compatibility with pre-C#8 bindings. foreach (var nest in iface.NestedTypes.Where(t => !t.Unnest)) { NestedTypes.Add(SourceWriterExtensions.BuildManagedTypeModel(nest, opt, context, genInfo)); } }
public InterfaceListenerEventHandlerHelper(InterfaceGen iface, Method method, string add, CodeGenerationOptions opt) { Name = add + "_Event_With_Handler_Helper"; Parameters.Add(new MethodParameterWriter("value", new TypeReferenceWriter(opt.GetOutputName(iface.FullName)))); ReturnType = TypeReferenceWriter.Void; SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); Body.Add($"{add} (value, null);"); }
void AddNestedTypes(ClassGen klass, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo genInfo) { foreach (var nest in klass.NestedTypes) { if (klass.BaseGen?.ContainsNestedType(nest) == true && nest is ClassGen c) { c.NeedsNew = true; } NestedTypes.Add(SourceWriterExtensions.BuildManagedTypeModel(nest, opt, context, genInfo)); } }
public GenericExplicitInterfaceImplementationProperty(Property property, GenericSymbol gen, string adapter, Dictionary <string, string> mappings, CodeGenerationOptions opt) { Name = property.AdjustedName; PropertyType = new TypeReferenceWriter(opt.GetTypeReferenceName(property)); ExplicitInterfaceImplementation = opt.GetOutputName(gen.Gen.FullName); Comments.Add($"// This method is explicitly implemented as a member of an instantiated {gen.FullName}"); if (property.Getter != null) { HasGet = true; if (gen.Gen.IsGeneratable) { GetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.Gen.MetadataXPathReference}/method[@name='{property.Getter.JavaName}'{property.Getter.Parameters.GetMethodXPathPredicate ()}]\""); } if (property.Getter.GenericArguments != null && property.Getter.GenericArguments.Any()) { GetterAttributes.Add(new CustomAttr(property.Getter.GenericArguments.ToGeneratedAttributeString())); } SourceWriterExtensions.AddSupportedOSPlatform(GetterAttributes, property.Getter, opt); GetterAttributes.Add(new RegisterAttr(property.Getter.JavaName, property.Getter.JniSignature, property.Getter.ConnectorName + ":" + property.Getter.GetAdapterName(opt, adapter), additionalProperties: property.Getter.AdditionalAttributeString())); GetBody.Add($"return {property.Name};"); } if (property.Setter != null) { HasSet = true; if (gen.Gen.IsGeneratable) { SetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.Gen.MetadataXPathReference}/method[@name='{property.Setter.JavaName}'{property.Setter.Parameters.GetMethodXPathPredicate ()}]\""); } if (property.Setter.GenericArguments != null && property.Setter.GenericArguments.Any()) { SetterAttributes.Add(new CustomAttr(property.Setter.GenericArguments.ToGeneratedAttributeString())); } SourceWriterExtensions.AddSupportedOSPlatform(SetterAttributes, property.Setter, opt); SetterAttributes.Add(new RegisterAttr(property.Setter.JavaName, property.Setter.JniSignature, property.Setter.ConnectorName + ":" + property.Setter.GetAdapterName(opt, adapter), additionalProperties: property.Setter.AdditionalAttributeString())); // Temporarily rename the parameter to "value" var pname = property.Setter.Parameters [0].Name; property.Setter.Parameters [0].Name = "value"; SetBody.Add($"{property.Name} = {property.Setter.Parameters.GetGenericCall (opt, mappings)};"); property.Setter.Parameters [0].Name = pname; } }
void AddFields(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context) { // Interface fields are only supported with DIM if (!opt.SupportInterfaceConstants && !opt.SupportDefaultInterfaceMethods) { return; } var seen = new HashSet <string> (); var fields = iface.GetGeneratableFields(opt).ToList(); SourceWriterExtensions.AddFields(this, iface, fields, seen, opt, context); }
public MethodExplicitInterfaceImplementation(GenBase iface, Method method, CodeGenerationOptions opt) { this.method = method; this.opt = opt; Name = method.Name; ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)); ExplicitInterfaceImplementation = opt.GetOutputName(iface.FullName); SourceWriterExtensions.AddMethodCustomAttributes(Attributes, method); this.AddMethodParameters(method.Parameters, opt); }
public BoundMethodAbstractDeclaration(GenBase gen, Method method, CodeGenerationOptions opt, GenBase impl) { this.method = method; this.opt = opt; ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)); this.AddMethodParameters(method.Parameters, opt); if (method.RetVal.IsGeneric && gen != null) { Name = method.Name; ExplicitInterfaceImplementation = opt.GetOutputName(gen.FullName); SourceWriterExtensions.AddMethodCustomAttributes(Attributes, method); Body.Add("throw new NotImplementedException ();"); return; } Name = method.AdjustedName; IsAbstract = true; IsShadow = impl.RequiresNew(method.Name, method); SetVisibility(method.Visibility); NewFirst = true; if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { method_callback = new MethodCallback(impl, method, opt, null, method.IsReturnCharSequence); } method.JavadocInfo?.AddJavadocs(Comments); if (method.DeclaringType.IsGeneratable) { Comments.Add($"// Metadata.xml XPath method reference: path=\"{method.GetMetadataXPathReference (method.DeclaringType)}\""); } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { Attributes.Add(new RegisterAttr(method.JavaName, method.JniSignature, method.ConnectorName, additionalProperties: method.AdditionalAttributeString())); } SourceWriterExtensions.AddMethodCustomAttributes(Attributes, method); }
public BoundInterfacePropertyDeclaration(GenBase gen, Property property, string adapter, CodeGenerationOptions opt) { Name = property.AdjustedName; PropertyType = new TypeReferenceWriter(opt.GetTypeReferenceName(property)); IsAutoProperty = true; if (property.Getter != null) { HasGet = true; if (gen.IsGeneratable) { GetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.MetadataXPathReference}/method[@name='{property.Getter.JavaName}'{property.Getter.Parameters.GetMethodXPathPredicate ()}]\""); } if (property.Getter.GenericArguments?.Any() == true) { GetterAttributes.Add(new CustomAttr(property.Getter.GenericArguments.ToGeneratedAttributeString())); } SourceWriterExtensions.AddSupportedOSPlatform(GetterAttributes, property.Getter, opt); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { GetterAttributes.Add(new RegisterAttr(property.Getter.JavaName, property.Getter.JniSignature, property.Getter.ConnectorName + ":" + property.Getter.GetAdapterName(opt, adapter), additionalProperties: property.Getter.AdditionalAttributeString())); } } if (property.Setter != null) { HasSet = true; if (gen.IsGeneratable) { SetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.MetadataXPathReference}/method[@name='{property.Setter.JavaName}'{property.Setter.Parameters.GetMethodXPathPredicate ()}]\""); } if (property.Setter.GenericArguments?.Any() == true) { SetterAttributes.Add(new CustomAttr(property.Setter.GenericArguments.ToGeneratedAttributeString())); } SourceWriterExtensions.AddSupportedOSPlatform(SetterAttributes, property.Setter, opt); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { SetterAttributes.Add(new RegisterAttr(property.Setter.JavaName, property.Setter.JniSignature, property.Setter.ConnectorName + ":" + property.Setter.GetAdapterName(opt, adapter), additionalProperties: property.Setter.AdditionalAttributeString())); } } }
public ExplicitInterfaceInvokerMethod(GenBase iface, Method method, CodeGenerationOptions opt) { this.method = method; this.opt = opt; Name = method.Name; IsUnsafe = true; ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)); ExplicitInterfaceImplementation = opt.GetOutputName(iface.FullName); this.AddMethodParameters(method.Parameters, opt); SourceWriterExtensions.AddMethodBody(Body, method, opt); }
// Historically .NET has not allowed interface implemented fields or constants, so we // initially worked around that by moving them to an abstract class, generally // IMyInterface -> MyInterfaceConsts // This was later expanded to accomodate static interface methods, creating a more appropriately named class // IMyInterface -> MyInterface // In this case the XXXConsts class is [Obsolete]'d and simply inherits from the newer class // in order to maintain backward compatibility. // If we're creating a binding that supports DIM, we remove the XXXConsts class as they've been // [Obsolete:iserror] for a long time, and we add [Obsolete] to the interface "class". public InterfaceMemberAlternativeClass(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context) { var should_obsolete = opt.SupportInterfaceConstants && opt.SupportDefaultInterfaceMethods; Name = iface.HasManagedName ? iface.Name.Substring(1) + "Consts" : iface.Name.Substring(1); Inherits = "Java.Lang.Object"; IsPublic = true; IsAbstract = true; UsePriorityOrder = true; SourceWriterExtensions.AddSupportedOSPlatform(Attributes, iface, opt); Attributes.Add(new RegisterAttr(iface.RawJniName, noAcw: true, additionalProperties: iface.AdditionalAttributeString()) { AcwLast = true }); if (should_obsolete) { Attributes.Add(new ObsoleteAttr($"Use the '{iface.FullName}' type. This class will be removed in a future release.") { WriteGlobal = true, NoAtSign = true }); } Constructors.Add(new ConstructorWriter { Name = Name, IsInternal = true }); var needs_class_ref = AddFields(iface, should_obsolete, opt, context); AddMethods(iface, should_obsolete, opt); if (needs_class_ref || iface.Methods.Where(m => m.IsStatic).Any()) { Fields.Add(new PeerMembersField(opt, iface.RawJniName, Name, false)); } if (!iface.HasManagedName && !opt.SupportInterfaceConstants) { sibling_classes.Add(new InterfaceConstsForwardClass(iface)); } }
public GenericExplicitInterfaceImplementationMethod(Method method, GenericSymbol gen, CodeGenerationOptions opt) { this.method = method; this.opt = opt; this.gen = gen; Name = method.Name; ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)); ExplicitInterfaceImplementation = opt.GetOutputName(gen.Gen.FullName); Comments.Add($"// This method is explicitly implemented as a member of an instantiated {gen.FullName}"); SourceWriterExtensions.AddMethodCustomAttributes(Attributes, method); this.AddMethodParameters(method.Parameters, opt); }
void AddMethods(ClassGen klass, CodeGenerationOptions opt, CodeGeneratorContext context) { var methodsToDeclare = klass.Methods.AsEnumerable(); // This does not exclude overrides (unlike virtual methods) because we're not sure // if calling the base interface default method via JNI expectedly dispatches to // the derived method. var defaultMethods = klass.GetAllDerivedInterfaces() .SelectMany(i => i.Methods) .Where(m => m.IsInterfaceDefaultMethod) .Where(m => !klass.ContainsMethod(m, false, false)); var overrides = defaultMethods.Where(m => m.OverriddenInterfaceMethod != null); var overridens = defaultMethods.Where(m => overrides.Where(_ => _.Name == m.Name && _.JniSignature == m.JniSignature) .Any(mm => mm.DeclaringType.GetAllDerivedInterfaces().Contains(m.DeclaringType))); methodsToDeclare = opt.SupportDefaultInterfaceMethods ? methodsToDeclare : methodsToDeclare.Concat(defaultMethods.Except(overridens)).Where(m => m.DeclaringType.IsGeneratable); foreach (var m in methodsToDeclare) { var virt = m.IsVirtual; m.IsVirtual = !klass.IsFinal && virt; if (m.IsAbstract && m.OverriddenInterfaceMethod == null && (opt.SupportDefaultInterfaceMethods || !m.IsInterfaceDefaultMethod)) { AddAbstractMethodDeclaration(klass, m, null); } else { AddMethod(klass, m, opt); } context.ContextGeneratedMethods.Add(m); m.IsVirtual = virt; } var methods = klass.Methods.Concat(klass.Properties.Where(p => p.Setter != null).Select(p => p.Setter)); foreach (var type in methods.Where(m => m.IsListenerConnector && m.EventName != string.Empty).Select(m => m.ListenerType).Distinct()) { AddInlineComment($"#region \"Event implementation for {type.FullName}\""); SourceWriterExtensions.AddInterfaceListenerEventsAndProperties(this, type, klass, opt); AddInlineComment("#endregion"); } }
public BoundFieldAsProperty(GenBase type, Field field, CodeGenerationOptions opt) { this.field = field; this.opt = opt; Name = field.Name; var fieldType = field.Symbol.IsArray ? "IList<" + field.Symbol.ElementType + ">" + opt.NullableOperator : opt.GetTypeReferenceName(field); PropertyType = new TypeReferenceWriter(fieldType); field.JavadocInfo?.AddJavadocs(Comments); Comments.Add($"// Metadata.xml XPath field reference: path=\"{type.MetadataXPathReference}/field[@name='{field.JavaName}']\""); if (field.IsEnumified) { Attributes.Add(new GeneratedEnumAttr()); } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, field, opt); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { Attributes.Add(new RegisterAttr(field.JavaName, additionalProperties: field.AdditionalAttributeString())); } if (field.IsDeprecated) { Attributes.Add(new ObsoleteAttr(field.DeprecatedComment, field.IsDeprecatedError) { NoAtSign = true }); } SetVisibility(field.Visibility); UseExplicitPrivateKeyword = true; IsStatic = field.IsStatic; HasGet = true; if (!field.IsConst) { HasSet = true; } }
public BoundPropertyStringVariant(Property property, CodeGenerationOptions opt) { var is_array = property.Getter.RetVal.IsArray; Name = property.Name; PropertyType = new TypeReferenceWriter("string" + (is_array ? "[]" : string.Empty)) { Nullable = opt.SupportNullableReferenceTypes }; SetVisibility((property.Setter ?? property.Getter).Visibility); SourceWriterExtensions.AddSupportedOSPlatform(Attributes, property.Getter, opt); HasGet = true; if (is_array) { GetBody.Add($"return CharSequence.ArrayToStringArray ({property.AdjustedName});"); } else { GetBody.Add($"return {property.AdjustedName} == null ? null : {property.AdjustedName}.ToString ();"); } if (property.Setter is null) { return; } HasSet = true; if (is_array) { SetBody.Add($"global::Java.Lang.ICharSequence[] jlsa = CharSequence.ArrayFromStringArray (value);"); SetBody.Add($"{property.AdjustedName} = jlsa;"); SetBody.Add($"foreach (var jls in jlsa) if (jls != null) jls.Dispose ();"); } else { SetBody.Add($"var jls = value == null ? null : new global::Java.Lang.String (value);"); SetBody.Add($"{property.AdjustedName} = jls;"); SetBody.Add($"if (jls != null) jls.Dispose ();"); } }
// static Delegate GetByteValueExactHandler () // { // if (cb_byteValueExact == null) // cb_byteValueExact = JNINativeWrapper.CreateDelegate ((_JniMarshal_PP_B) n_ByteValueExact); // return cb_byteValueExact; // } public GetDelegateHandlerMethod(Method method, CodeGenerationOptions opt) { this.method = method; this.opt = opt; Name = method.ConnectorName; ReturnType = TypeReferenceWriter.Delegate; IsStatic = true; IsPrivate = method.IsInterfaceDefaultMethod; if (!string.IsNullOrWhiteSpace(method.Deprecated)) { Attributes.Add(new ObsoleteAttr()); } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); }
public InterfaceConstsClass(ClassGen klass, HashSet <string> seen, CodeGenerationOptions opt, CodeGeneratorContext context) { Name = "InterfaceConsts"; IsPublic = true; IsStatic = true; UsePriorityOrder = true; foreach (var iface in klass.GetAllImplementedInterfaces() .Except(klass.BaseGen?.GetAllImplementedInterfaces() ?? new InterfaceGen [0]) .Where(i => i.Fields.Count > 0)) { AddInlineComment($"// The following are fields from: {iface.JavaName}"); SourceWriterExtensions.AddFields(this, iface, iface.Fields, seen, opt, context); } }
public InterfaceInvokerMethod(InterfaceGen iface, Method method, CodeGenerationOptions opt, CodeGeneratorContext context) { this.method = method; this.opt = opt; Name = method.AdjustedName; ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)); IsPublic = true; IsUnsafe = true; IsStatic = method.IsStatic; method_callback = new MethodCallback(iface, method, opt, null, method.IsReturnCharSequence); context_this = context.ContextType.GetObjectHandleProperty(opt, "this"); SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); this.AddMethodParameters(method.Parameters, opt); }
public BoundConstructor(ClassGen klass, Ctor constructor, bool useBase, CodeGenerationOptions opt, CodeGeneratorContext context) { this.constructor = constructor; this.opt = opt; this.context = context; Name = klass.Name; constructor.JavadocInfo?.AddJavadocs(Comments); Comments.Add(string.Format("// Metadata.xml XPath constructor reference: path=\"{0}/constructor[@name='{1}'{2}]\"", klass.MetadataXPathReference, klass.JavaSimpleName, constructor.Parameters.GetMethodXPathPredicate())); SourceWriterExtensions.AddSupportedOSPlatform(Attributes, constructor, opt); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { Attributes.Add(new RegisterAttr(".ctor", constructor.JniSignature, string.Empty, additionalProperties: constructor.AdditionalAttributeString())); } if (constructor.Deprecated != null) { Attributes.Add(new ObsoleteAttr(constructor.Deprecated.Replace("\"", "\"\""))); } if (constructor.CustomAttributes != null) { Attributes.Add(new CustomAttr(constructor.CustomAttributes)); } if (constructor.Annotation != null) { Attributes.Add(new CustomAttr(constructor.Annotation)); } SetVisibility(constructor.Visibility); IsUnsafe = true; BaseCall = opt.CodeGenerationTarget == CodeGenerationTarget.JavaInterop1 ? $"{(useBase ? "base" : "this")} (ref *InvalidJniObjectReference, JniObjectReferenceOptions.None)" : $"{(useBase ? "base" : "this")} (IntPtr.Zero, JniHandleOwnership.DoNotTransfer)"; context_this = context.ContextType.GetObjectHandleProperty(opt, "this"); this.AddMethodParameters(constructor.Parameters, opt); }
void AddInterfaceEventHandler(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context) { if (!iface.IsListener) { return; } foreach (var method in iface.Methods.Where(m => m.EventName != string.Empty)) { if (method.RetVal.IsVoid || method.IsEventHandlerWithHandledProperty) { if (!method.IsSimpleEventHandler || method.IsEventHandlerWithHandledProperty) { var event_args_class = post_sibling_types.OfType <InterfaceEventArgsClass> ().SingleOrDefault(c => c.Name == iface.GetArgsName(method)); // Check if there's an existing EventArgs class to add to if (event_args_class is null) { event_args_class = new InterfaceEventArgsClass(iface, method); post_sibling_types.Add(event_args_class); } event_args_class.AddMembersFromMethod(iface, method, opt); } } else { var del = new DelegateWriter { Name = iface.GetEventDelegateName(method), Type = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)), IsPublic = true }; SourceWriterExtensions.AddMethodParameters(del, method.Parameters, opt); post_sibling_types.Add(del); } } post_sibling_types.Add(new InterfaceEventHandlerImplClass(iface, opt, context)); }
public BoundMethodStringOverload(Method method, CodeGenerationOptions opt) { this.method = method; this.opt = opt; Name = method.Name; IsStatic = method.IsStatic; SetVisibility(method.Visibility); ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal).Replace("Java.Lang.ICharSequence", "string").Replace("global::string", "string")); if (method.Deprecated != null) { Attributes.Add(new ObsoleteAttr(method.Deprecated.Replace("\"", "\"\"").Trim())); } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); method.JavadocInfo?.AddJavadocs(Comments); this.AddMethodParametersStringOverloads(method.Parameters, opt); }
public BoundInterfaceMethodDeclaration(Method method, string adapter, CodeGenerationOptions opt) { this.method = method; this.opt = opt; Name = method.AdjustedName; ReturnType = new TypeReferenceWriter(opt.GetTypeReferenceName(method.RetVal)); IsDeclaration = true; if (method.DeclaringType.IsGeneratable) { Comments.Add($"// Metadata.xml XPath method reference: path=\"{method.GetMetadataXPathReference (method.DeclaringType)}\""); } if (method.Deprecated != null) { Attributes.Add(new ObsoleteAttr(method.Deprecated.Replace("\"", "\"\""))); } if (method.IsReturnEnumified) { Attributes.Add(new GeneratedEnumAttr(true)); } if (method.IsInterfaceDefaultMethod) { Attributes.Add(new CustomAttr("[global::Java.Interop.JavaInterfaceDefaultMethod]")); } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { Attributes.Add(new RegisterAttr(method.JavaName, method.JniSignature, method.ConnectorName + ":" + method.GetAdapterName(opt, adapter), additionalProperties: method.AdditionalAttributeString())); } method.JavadocInfo?.AddJavadocs(Comments); SourceWriterExtensions.AddMethodCustomAttributes(Attributes, method); this.AddMethodParameters(method.Parameters, opt); }
public MethodAsyncWrapper(Method method, CodeGenerationOptions opt) { this.method = method; this.opt = opt; Name = method.AdjustedName + "Async"; IsStatic = method.IsStatic; SetVisibility(method.Visibility); ReturnType = new TypeReferenceWriter("global::System.Threading.Tasks.Task"); if (!method.IsVoid) { ReturnType.Name += "<" + opt.GetTypeReferenceName(method.RetVal) + ">"; } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, method, opt); Body.Add($"return global::System.Threading.Tasks.Task.Run (() => {method.AdjustedName} ({method.Parameters.GetCall (opt)}));"); this.AddMethodParameters(method.Parameters, opt); }
bool AddInterfaceFields(InterfaceGen iface, List <Field> fields, HashSet <string> seen, CodeGenerationOptions opt, CodeGeneratorContext context) { var needs_property = false; foreach (var f in fields) { if (iface.ContainsName(f.Name)) { Report.LogCodedWarning(0, SourceWriterExtensions.GetFieldCollisionMessage(iface, f), f, iface.FullName, f.Name, iface.JavaName); continue; } if (seen.Contains(f.Name)) { Report.LogCodedWarning(0, Report.WarningDuplicateField, f, iface.FullName, f.Name, iface.JavaName); continue; } if (f.Validate(opt, iface.TypeParameters, context)) { seen.Add(f.Name); needs_property = needs_property || f.NeedsProperty; if (f.NeedsProperty) { Properties.Add(new BoundFieldAsProperty(iface, f, opt)); } else { Fields.Add(new BoundField(iface, f, opt)); } } } return(needs_property); }
public BoundProperty(GenBase gen, Property property, CodeGenerationOptions opt, bool withCallbacks = true, bool forceOverride = false) { Name = property.AdjustedName; PropertyType = new TypeReferenceWriter(opt.GetTypeReferenceName(property.Getter.RetVal)); SetVisibility(gen is InterfaceGen ? string.Empty : property.Getter.IsAbstract && property.Getter.RetVal.IsGeneric ? "protected" : (property.Setter ?? property.Getter).Visibility); IsUnsafe = true; HasGet = true; var is_virtual = property.Getter.IsVirtual && (property.Setter == null || property.Setter.IsVirtual); if (is_virtual && withCallbacks) { IsVirtual = true; IsShadow = gen.RequiresNew(property); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { getter_callback = new MethodCallback(gen, property.Getter, opt, property.AdjustedName, false); } if (property.Setter != null && opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { setter_callback = new MethodCallback(gen, property.Setter, opt, property.AdjustedName, false); } } if (forceOverride || ShouldForceOverride(property)) { IsVirtual = false; IsOverride = true; } if ((property.Getter ?? property.Setter).IsStatic) { IsStatic = true; IsVirtual = false; IsOverride = false; } else if (gen.BaseSymbol != null) { // It should be using AdjustedName instead of Name, but ICharSequence ("Formatted") properties are not caught by this... var base_prop = gen.BaseSymbol.GetPropertyByName(property.Name, true); // If the matching base getter we found is a DIM, we do not override it, it should stay virtual if (base_prop != null && !base_prop.Getter.IsInterfaceDefaultMethod) { IsVirtual = false; IsOverride = true; } } // Allow user to override our virtual/override logic if (!forceOverride && (property.Getter ?? property.Setter).ManagedOverride?.ToLowerInvariant() == "virtual") { IsVirtual = true; IsOverride = false; } else if (!forceOverride && (property.Getter ?? property.Setter).ManagedOverride?.ToLowerInvariant() == "override") { IsVirtual = false; IsOverride = true; } // Unlike [Register], [Obsolete] cannot be put on property accessors, so we can apply them only under limited condition... if (property.Getter.Deprecated != null && (property.Setter == null || property.Setter.Deprecated != null)) { Attributes.Add(new ObsoleteAttr(property.Getter.Deprecated.Replace("\"", "\"\"").Trim() + (property.Setter != null && property.Setter.Deprecated != property.Getter.Deprecated ? " " + property.Setter.Deprecated.Replace("\"", "\"\"").Trim() : null))); } SourceWriterExtensions.AddSupportedOSPlatform(Attributes, property.Getter, opt); SourceWriterExtensions.AddMethodCustomAttributes(GetterAttributes, property.Getter); if (gen.IsGeneratable) { GetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.MetadataXPathReference}/method[@name='{property.Getter.JavaName}'{property.Getter.Parameters.GetMethodXPathPredicate ()}]\""); } if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { GetterAttributes.Add(new RegisterAttr(property.Getter.JavaName, property.Getter.JniSignature, property.Getter.IsVirtual ? property.Getter.GetConnectorNameFull(opt) : string.Empty, additionalProperties: property.Getter.AdditionalAttributeString())); } SourceWriterExtensions.AddMethodBody(GetBody, property.Getter, opt); if (property.Setter != null) { HasSet = true; if (gen.IsGeneratable) { SetterComments.Add($"// Metadata.xml XPath method reference: path=\"{gen.MetadataXPathReference}/method[@name='{property.Setter.JavaName}'{property.Setter.Parameters.GetMethodXPathPredicate ()}]\""); } SourceWriterExtensions.AddSupportedOSPlatform(SetterAttributes, property.Setter, opt); SourceWriterExtensions.AddMethodCustomAttributes(SetterAttributes, property.Setter); if (opt.CodeGenerationTarget != CodeGenerationTarget.JavaInterop1) { SetterAttributes.Add(new RegisterAttr(property.Setter.JavaName, property.Setter.JniSignature, property.Setter.IsVirtual ? property.Setter.GetConnectorNameFull(opt) : string.Empty, additionalProperties: property.Setter.AdditionalAttributeString())); } var pname = property.Setter.Parameters [0].Name; property.Setter.Parameters [0].Name = "value"; SourceWriterExtensions.AddMethodBody(SetBody, property.Setter, opt); property.Setter.Parameters [0].Name = pname; } else if (property.GenerateDispatchingSetter) { HasSet = true; SetterComments.Add("// This is a dispatching setter"); SetBody.Add($"Set{property.Name} (value);"); } AddJavadocs(property); }
protected override void WriteBody(CodeWriter writer) { SourceWriterExtensions.WriteMethodStringOverloadBody(writer, method, opt, false); }
public BoundClass(ClassGen klass, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo generationInfo) { context.ContextTypes.Push(klass); context.ContextGeneratedMethods = new List <Method> (); generationInfo.TypeRegistrations.Add(new KeyValuePair <string, string> (klass.RawJniName, klass.AssemblyQualifiedName)); var is_enum = klass.base_symbol != null && klass.base_symbol.FullName == "Java.Lang.Enum"; if (is_enum) { generationInfo.Enums.Add(klass.RawJniName.Replace('/', '.') + ":" + klass.Namespace + ":" + klass.JavaSimpleName); } this.opt = opt; Name = klass.Name; SetVisibility(klass.Visibility); IsShadow = klass.NeedsNew; IsAbstract = klass.IsAbstract; IsSealed = klass.IsFinal; IsPartial = true; UsePriorityOrder = true; AddImplementedInterfaces(klass); Comments.Add($"// Metadata.xml XPath class reference: path=\"{klass.MetadataXPathReference}\""); if (klass.IsDeprecated) { Attributes.Add(new ObsoleteAttr(klass.DeprecatedComment) { WriteAttributeSuffix = true }); } Attributes.Add(new RegisterAttr(klass.RawJniName, null, null, true, klass.AdditionalAttributeString()) { UseGlobal = true, UseShortForm = true }); if (klass.TypeParameters != null && klass.TypeParameters.Any()) { Attributes.Add(new CustomAttr(klass.TypeParameters.ToGeneratedAttributeString())); } // Figure out our base class string obj_type = null; if (klass.base_symbol != null) { obj_type = klass.base_symbol is GenericSymbol gs && gs.IsConcrete ? gs.GetGenericType(null) : opt.GetOutputName(klass.base_symbol.FullName); } if (klass.InheritsObject && obj_type != null) { Inherits = obj_type; } // Handle fields var seen = new HashSet <string> (); SourceWriterExtensions.AddFields(this, klass, klass.Fields, seen, opt, context); var ic = new InterfaceConstsClass(klass, seen, opt, context); if (ic.ShouldGenerate) { NestedTypes.Add(ic); } // Sibling classes if (!klass.AssemblyQualifiedName.Contains('/')) { foreach (InterfaceExtensionInfo nestedIface in klass.GetNestedInterfaceTypes()) { if (nestedIface.Type.Methods.Any(m => m.CanHaveStringOverload) || nestedIface.Type.Methods.Any(m => m.Asyncify)) { sibling_types.Add(new InterfaceExtensionsClass(nestedIface.Type, nestedIface.DeclaringType, opt)); } } } if (klass.IsAbstract) { sibling_types.Add(new ClassInvokerClass(klass, opt)); } AddNestedTypes(klass, opt, context, generationInfo); AddBindingInfrastructure(klass); AddConstructors(klass, opt, context); AddProperties(klass, opt); AddMethods(klass, opt, context); AddAbstractMembers(klass, opt, context); AddExplicitGenericInterfaceMembers(klass, opt); AddCharSequenceEnumerator(klass); context.ContextGeneratedMethods.Clear(); context.ContextTypes.Pop(); }
protected override void WriteGetterBody(CodeWriter writer) { SourceWriterExtensions.WriteMethodInvokerBody(writer, property.Getter, opt, context_this); }