public static JavaFieldModel ParseField(JavaTypeModel type, XElement element)
{
var field = new JavaFieldModel(
name: element.XGetAttribute("name"),
visibility: element.XGetAttribute("visibility"),
type: element.XGetAttribute("type"),
typeGeneric: element.XGetAttribute("type-generic-aware"),
isStatic: element.XGetAttributeAsBool("static"),
value: element.Attribute("value")?.Value,
declaringType: type,
isFinal: element.XGetAttributeAsBool("final"),
deprecated: element.XGetAttribute("deprecated"),
jniSignature: element.XGetAttribute("jni-signature"),
isTransient: element.XGetAttributeAsBool("transient"),
isVolatile: element.XGetAttributeAsBool("volatile"),
isNotNull: element.XGetAttributeAsBool("not-null")
);
if (element.XGetAttribute("merge.SourceFile") is string source && source.HasValue())
{
field.PropertyBag.Add("merge.SourceFile", source);
}
if (element.XGetAttribute("deprecated-since") is string dep && dep.HasValue())
{
field.PropertyBag.Add("deprecated-since", dep);
}
return(field);
}
static void AddReferenceTypeRecursive(JavaTypeModel type, JavaTypeCollection collection)
{
collection.AddReferencedType(type);
foreach (var nested in type.NestedTypes)
{
AddReferenceTypeRecursive(nested, collection);
}
}
static void SaveType(JavaTypeModel type, XmlWriter writer)
{
if (type is JavaClassModel cls)
{
SaveType(type, writer, "class", XmlConvert.ToString(cls.IsAbstract), cls.BaseType, cls.BaseTypeGeneric, cls.BaseTypeJni);
}
else
{
SaveType(type, writer, "interface", "true", null, null, null);
}
foreach (var nested in type.NestedTypes)
{
SaveType(nested, writer);
}
}
public static JavaMethodModel ParseMethod(JavaTypeModel type, XElement element)
{
var method = new JavaMethodModel(
javaName: element.XGetAttribute("name"),
javaVisibility: element.XGetAttribute("visibility"),
javaAbstract: element.XGetAttributeAsBool("abstract"),
javaFinal: element.XGetAttributeAsBool("final"),
javaStatic: element.XGetAttributeAsBool("static"),
javaReturn: element.XGetAttribute("return"),
javaDeclaringType: type,
deprecated: element.XGetAttribute("deprecated"),
jniSignature: element.XGetAttribute("jni-signature"),
isSynthetic: element.XGetAttributeAsBool("synthetic"),
isBridge: element.XGetAttributeAsBool("bridge"),
returnJni: element.XGetAttribute("jni-return"),
isNative: element.XGetAttributeAsBool("native"),
isSynchronized: element.XGetAttributeAsBool("synchronized"),
returnNotNull: element.XGetAttributeAsBool("return-not-null")
);
if (element.Element("typeParameters") is XElement tp)
{
ParseTypeParameters(method.TypeParameters, tp);
}
foreach (var child in element.Elements("parameter"))
{
method.Parameters.Add(ParseParameter(method, child));
}
foreach (var child in element.Elements("exception"))
{
method.Exceptions.Add(ParseException(child));
}
if (element.XGetAttribute("merge.SourceFile") is string source && source.HasValue())
{
method.PropertyBag.Add("merge.SourceFile", source);
}
if (element.XGetAttribute("deprecated-since") is string dep && dep.HasValue())
{
method.PropertyBag.Add("deprecated-since", dep);
}
return(method);
}
public static JavaMethodModel?ParseMethod(MethodDefinition method, JavaTypeModel declaringType)
{
if (method.IsPrivate || method.IsAssembly)
{
return(null);
}
var obs_attr = GetObsoleteAttribute(method.CustomAttributes);
var reg_attr = GetRegisterAttribute(method.CustomAttributes);
if (reg_attr is null)
{
return(null);
}
var deprecated = (obs_attr != null) ? (string)obs_attr.ConstructorArguments [0].Value ?? "deprecated" : "not deprecated";
var jni_signature = JniSignature.Parse((string)reg_attr.ConstructorArguments [1].Value !);
var model = new JavaMethodModel(
javaName: (string)reg_attr.ConstructorArguments [0].Value,
javaVisibility: method.Visibility(),
javaAbstract: method.IsAbstract,
javaFinal: method.IsFinal,
javaStatic: method.IsStatic,
javaReturn: jni_signature.Return.Type,
javaDeclaringType: declaringType,
deprecated: deprecated,
jniSignature: jni_signature.ToString(),
isSynthetic: false,
isBridge: false,
returnJni: jni_signature.Return.Jni,
isNative: false,
isSynchronized: false,
returnNotNull: false
);
for (var i = 0; i < jni_signature.Parameters.Count; i++)
{
model.Parameters.Add(ParseParameterModel(model, jni_signature.Parameters [i], method.Parameters [i]));
}
return(model);
}
static void ParseImplementedInterfaces(TypeDefinition type, JavaTypeModel model)
{
foreach (var iface_impl in type.Interfaces)
{
var iface = iface_impl.InterfaceType;
var iface_def = iface.Resolve();
if (iface_def is null || iface_def.IsNotPublic)
{
continue;
}
if (GetRegisterAttribute(iface_def.CustomAttributes) is CustomAttribute reg_attr)
{
var jni = (string)reg_attr.ConstructorArguments [0].Value;
var name = jni.Replace('/', '.').Replace('$', '.');
model.Implements.Add(new JavaImplementsModel(name, name, $"L{jni};"));
}
}
}
public static JavaConstructorModel ParseConstructor(JavaTypeModel type, XElement element)
{
var method = new JavaConstructorModel(
javaName: element.XGetAttribute("name"),
javaVisibility: element.XGetAttribute("visibility"),
javaStatic: element.XGetAttributeAsBool("static"),
javaDeclaringType: type,
deprecated: element.XGetAttribute("deprecated"),
jniSignature: element.XGetAttribute("jni-signature"),
isSynthetic: element.XGetAttributeAsBool("synthetic"),
isBridge: element.XGetAttributeAsBool("bridge")
);
// Yes, constructors in Java can have generic type parameters ¯\_(ツ)_/¯
if (element.Element("typeParameters") is XElement tp)
{
ParseTypeParameters(method.TypeParameters, tp);
}
foreach (var child in element.Elements("exception"))
{
method.Exceptions.Add(ParseException(child));
}
foreach (var child in element.Elements("parameter"))
{
method.Parameters.Add(ParseParameter(method, child));
}
if (element.XGetAttribute("merge.SourceFile") is string source && source.HasValue())
{
method.PropertyBag.Add("merge.SourceFile", source);
}
if (element.XGetAttribute("deprecated-since") is string dep && dep.HasValue())
{
method.PropertyBag.Add("deprecated-since", dep);
}
return(method);
}
static void SaveType(JavaTypeModel cls, XmlWriter writer, string elementName, string abs, string?ext, string?extgen, string?jniExt)
{
writer.WriteStartElement(elementName);
writer.WriteAttributeStringIfValue("abstract", abs);
writer.WriteAttributeString("deprecated", cls.Deprecated);
writer.WriteAttributeStringIfValue("extends", ext);
writer.WriteAttributeStringIfValue("extends-generic-aware", extgen);
writer.WriteAttributeStringIfValue("jni-extends", jniExt);
writer.WriteAttributeString("final", XmlConvert.ToString(cls.IsFinal));
writer.WriteAttributeString("name", cls.NestedName);
writer.WriteAttributeString("static", XmlConvert.ToString(cls.IsStatic));
writer.WriteAttributeString("visibility", cls.Visibility);
writer.WriteAttributeStringIfValue("jni-signature", cls.ExtendedJniSignature);
if (cls.PropertyBag.TryGetValue("merge.SourceFile", out var source))
{
writer.WriteAttributeString("merge.SourceFile", source);
}
if (cls.PropertyBag.TryGetValue("deprecated-since", out var dep))
{
writer.WriteAttributeString("deprecated-since", dep);
}
SaveTypeParameters(cls.TypeParameters, writer);
foreach (var imp in cls.Implements.OrderBy(i => i.Name, StringComparer.Ordinal))
{
writer.WriteStartElement("implements");
writer.WriteAttributeString("name", imp.Name);
writer.WriteAttributeString("name-generic-aware", imp.NameGeneric);
writer.WriteAttributeStringIfValue("jni-type", imp.JniType);
if (imp.PropertyBag.TryGetValue("merge.SourceFile", out var imp_source))
{
writer.WriteAttributeString("merge.SourceFile", imp_source);
}
WriteFullEndElement(writer);
}
if (cls is JavaClassModel klass)
{
foreach (var m in klass.Constructors.OrderBy(m => m.Name, StringComparer.OrdinalIgnoreCase).ThenBy(m => string.Join(", ", m.Parameters.Select(p => p.Type))).ThenBy(m => m.IsSynthetic))
{
SaveConstructor(m, writer);
}
}
foreach (var m in cls.Methods.OrderBy(m => m.Name, StringComparer.Ordinal).ThenBy(m => string.Join(", ", m.Parameters.Select(p => p.Type))).ThenBy(m => m.IsSynthetic))
{
SaveMethod(m, writer);
}
foreach (var m in cls.Fields.OrderBy(m => m.Name, StringComparer.OrdinalIgnoreCase))
{
SaveField(m, writer);
}
WriteFullEndElement(writer);
}
