internal static void Load(this JavaTypeParameters tps, XmlReader reader)
        {
            reader.MoveToContent();
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </typeParameters>
                    }
                    if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "typeParameter")
                    {
                        throw XmlUtil.UnexpectedElementOrContent("typeParameters", reader, "typeParameter");
                    }
                    var tp = new JavaTypeParameter(tps);
                    tp.Load(reader);
                    tps.TypeParameters.Add(tp);
                } while (true);

                XmlUtil.VerifyEndElement(reader, "typeParameters");
                reader.Read();
            }
        }
        public static void Load(this JavaGenericConstraints gcs, XmlReader reader)
        {
            reader.MoveToContent();

            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();

                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </genericConstraints>
                    }
                    if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "genericConstraint")
                    {
                        throw XmlUtil.UnexpectedElementOrContent("genericConstraints", reader, "genericConstraint");
                    }
                    var gc = new JavaGenericConstraint();
                    gc.Load(reader);
                    gcs.GenericConstraints.Add(gc);
                } while (true);

                XmlUtil.VerifyEndElement(reader, "genericConstraints");
                reader.Read();
            }
        }
        public static void Load(this JavaInterface iface, XmlReader reader)
        {
            reader.MoveToContent();
            iface.LoadTypeAttributes(reader);
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </interface>
                    }
                    if (reader.NodeType != XmlNodeType.Element)
                    {
                        throw XmlUtil.UnexpectedElementOrContent("interface", reader, "implements", "typeParameters", "field", "method");
                    }
                    if (!iface.TryLoadCommonElement(reader))
                    {
                        throw XmlUtil.UnexpectedElementOrContent("interface", reader, "implements", "typeParameters", "field", "method");
                    }
                } while (true);

                XmlUtil.VerifyEndElement(reader, "interface");
                reader.Read();
            }
        }
        public static void Load(this JavaPackage package, XmlReader reader, bool isReferenceOnly)
        {
            reader.MoveToContent();
            package.Name    = XmlUtil.GetRequiredAttribute(reader, "name");
            package.JniName = reader.GetAttribute("jni-name");
            if (reader.MoveToFirstAttribute())
            {
                if (reader.LocalName != "name")
                {
                    throw XmlUtil.UnexpectedAttribute(reader, "package");
                }
            }
            reader.MoveToElement();
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </package>
                    }
                    if (reader.NodeType != XmlNodeType.Element)
                    {
                        throw XmlUtil.UnexpectedElementOrContent("package", reader, "class", "interface");
                    }
                    if (reader.LocalName == "class")
                    {
                        var kls = new JavaClass(package)
                        {
                            IsReferenceOnly = isReferenceOnly
                        };
                        kls.Load(reader);
                        package.AddType(kls);
                    }
                    else if (reader.LocalName == "interface")
                    {
                        var iface = new JavaInterface(package)
                        {
                            IsReferenceOnly = isReferenceOnly
                        };
                        iface.Load(reader);
                        package.AddType(iface);
                    }
                    else
                    {
                        throw XmlUtil.UnexpectedElementOrContent("package", reader, "class", "interface");
                    }
                } while (true);

                XmlUtil.VerifyEndElement(reader, "package");
                reader.Read();
            }
        }
Ejemplo n.º 5
0
        static void LoadMethodBase(this JavaMethodBase methodBase, string elementName, XmlReader reader)
        {
            var method = methodBase as JavaMethod;             // kind of ugly hack yeah...

            methodBase.LoadMemberAttributes(reader);
            //methodBase.ExtendedJniSignature = reader.GetAttribute ("jni-signature");
            methodBase.ExtendedJniReturn = reader.GetAttribute("jni-return");
            methodBase.ExtendedSynthetic = XmlConvert.ToBoolean(reader.GetAttribute("synthetic") ?? "false");
            methodBase.ExtendedBridge    = XmlConvert.ToBoolean(reader.GetAttribute("bridge") ?? "false");

            reader.MoveToElement();
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                    if (reader.NodeType != XmlNodeType.Element)
                    {
                        throw XmlUtil.UnexpectedElementOrContent(elementName, reader, "parameter");
                    }
                    if (reader.LocalName == "typeParameters")
                    {
                        var tp = new JavaTypeParameters(methodBase);
                        tp.Load(reader);
                        methodBase.TypeParameters = tp;
                    }
                    else if (reader.LocalName == "parameter")
                    {
                        var p = new JavaParameter(methodBase);
                        p.Load(reader);
                        methodBase.Parameters.Add(p);
                    }
                    else if (reader.LocalName == "exception")
                    {
                        var p = new JavaException();
                        p.Load(reader);
                        methodBase.Exceptions.Add(p);
                    }
                    else
                    {
                        throw XmlUtil.UnexpectedElementOrContent(elementName, reader, "parameter");
                    }
                } while (true);
                XmlUtil.VerifyEndElement(reader, elementName);
                reader.Read();
            }
        }
        public static void Load(this JavaClass kls, XmlReader reader)
        {
            reader.MoveToContent();
            kls.LoadTypeAttributes(reader, "extends", "extends-generic-aware", "jni-extends");
            // they are not mandatory; Java.Lang.Object doesn't have them.
            kls.Extends            = reader.GetAttribute("extends");
            kls.ExtendsGeneric     = reader.GetAttribute("extends-generic-aware");
            kls.ExtendedJniExtends = reader.GetAttribute("jni-extends");

            reader.MoveToElement();
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </interface>
                    }
                    if (reader.NodeType != XmlNodeType.Element)
                    {
                        throw XmlUtil.UnexpectedElementOrContent("class", reader, "implements", "typeParameters", "field", "constructor", "method");
                    }
                    if (!kls.TryLoadCommonElement(reader))
                    {
                        if (reader.LocalName == "constructor")
                        {
                            var constructor = new JavaConstructor(kls);
                            constructor.Load(reader);
                            kls.Members.Add(constructor);
                        }
                        else
                        {
                            throw XmlUtil.UnexpectedElementOrContent("class", reader, "implements", "typeParameters", "field", "constructor", "method");
                        }
                    }
                } while (true);
                XmlUtil.VerifyEndElement(reader, "class");
                reader.Read();
            }
        }
        public static void Load(this JavaApi api, XmlReader reader, bool isReferenceOnly)
        {
            reader.MoveToContent();
            if (reader.LocalName != "api")
            {
                throw XmlUtil.UnexpectedElementOrContent(null, reader, "api");
            }
            api.ExtendedApiSource = reader.GetAttribute("api-source");
            api.Platform          = reader.GetAttribute("platform");
            XmlUtil.CheckExtraneousAttributes("api", reader, "api-source", "platform");
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </api>
                    }
                    if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "package")
                    {
                        throw XmlUtil.UnexpectedElementOrContent("api", reader, "package");
                    }

                    var name = reader.GetAttribute("name");

                    if (!api.Packages.TryGetValue(name, out var pkg))
                    {
                        pkg = new JavaPackage(api);
                        api.Packages.Add(name, pkg);
                    }

                    pkg.Load(reader, isReferenceOnly);
                } while (true);

                XmlUtil.VerifyEndElement(reader, "api");
                reader.Read();
            }
        }
        public static void Load(this JavaTypeParameter tp, XmlReader reader)
        {
            tp.Name = XmlUtil.GetRequiredAttribute(reader, "name");
            tp.ExtendedJniClassBound = reader.GetAttribute("jni-classBound");
            // such an ill-named attribute...
            tp.ExtendedClassBound = reader.GetAttribute("classBound");
            // and un-structuring attribute...
            tp.ExtendedInterfaceBounds    = reader.GetAttribute("interfaceBounds");
            tp.ExtendedJniInterfaceBounds = reader.GetAttribute("jni-interfaceBounds");
            XmlUtil.CheckExtraneousAttributes("typeParameter", reader, "name", "jni-classBound", "jni-interfaceBounds", "classBound", "interfaceBounds");
            if (reader.IsEmptyElement)
            {
                reader.Read();
            }
            else
            {
                reader.Read();
                do
                {
                    reader.MoveToContent();
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        break;                         // </typeParameter>
                    }
                    if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "genericConstraints")
                    {
                        throw XmlUtil.UnexpectedElementOrContent("typeParameter", reader, "genericConstraints");
                    }

                    var gc = new JavaGenericConstraints();
                    gc.Load(reader);
                    tp.GenericConstraints = gc;
                } while (true);

                XmlUtil.VerifyEndElement(reader, "typeParameter");
                reader.Read();
            }
            // Now we have to deal with the format difference...
            // Some versions of class-parse stopped generating <genericConstraints> but started
            // generating "classBound" and "interfaceBounds" attributes instead.
            // They don't make sense and blocking this effort, but we have to deal with that...
            if (!string.IsNullOrEmpty(tp.ExtendedClassBound) || !string.IsNullOrEmpty(tp.ExtendedInterfaceBounds))
            {
                var gcs = new JavaGenericConstraints();
                if (!string.IsNullOrEmpty(tp.ExtendedClassBound))
                {
                    gcs.GenericConstraints.Add(new JavaGenericConstraint()
                    {
                        Type = tp.ExtendedClassBound
                    });
                }
                if (!string.IsNullOrEmpty(tp.ExtendedInterfaceBounds))
                {
                    foreach (var ic in tp.ExtendedInterfaceBounds.Split(':'))
                    {
                        gcs.GenericConstraints.Add(new JavaGenericConstraint()
                        {
                            Type = ic
                        });
                    }
                }
                tp.GenericConstraints = gcs;
            }
        }