org.xmlpull.v1.wrapper.classic.StaticXmlPullParserWrapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of xpp3 Show documentation
The newest version!
/* -*-             c-basic-offset: 4; indent-tabs-mode: nil; -*-  //------100-columns-wide------>|*/
// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/)

package org.xmlpull.v1.wrapper.classic;

import java.io.IOException;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.wrapper.XmlPullParserWrapper;
import org.xmlpull.v1.util.XmlPullUtil;

/**
 * This class seemlesly extends exisiting parser implementation by adding new methods
 * (provided by XmlPullUtil) and delegating exisiting methods to parser implementation.
 *
 * @author Aleksander Slominski
 * @author Naresh Bhatia
 */
public class StaticXmlPullParserWrapper extends XmlPullParserDelegate
    implements XmlPullParserWrapper
{
    public StaticXmlPullParserWrapper(XmlPullParser pp) {
        super(pp);
    }

    public String getAttributeValue(String name)
    {
        return XmlPullUtil.getAttributeValue(pp, name);
    }

    public String getRequiredAttributeValue(String name)
        throws IOException, XmlPullParserException
    {
        return XmlPullUtil.getRequiredAttributeValue(pp, null, name);
    }


    public String getRequiredAttributeValue(String namespace, String name)
        throws IOException, XmlPullParserException
    {
        return XmlPullUtil.getRequiredAttributeValue(pp, namespace, name);
    }


    /**
     * Read the text of a required element and return it or throw exception if
     * required element is not found. Useful for getting the text of simple
     * elements such as johndoe. Assumes that parser is
     * just before the start tag and leaves the parser at the end tag. If the
     * text is nil (e.g. ), then a null will be returned.
     */

    public String getRequiredElementText(String namespace, String name)
        throws IOException, XmlPullParserException
    {
        if (name == null) {
            throw new XmlPullParserException("name for element can not be null");
        }

        String text = null;
        nextStartTag(namespace, name);
        if (isNil()) {
            nextEndTag(namespace, name);
        }
        else {
            text = pp.nextText();
        }
        pp.require(XmlPullParser.END_TAG, namespace, name);
        return text;
    }

    public boolean isNil()
        throws IOException, XmlPullParserException
    {

        boolean result = false;
        String value = pp.getAttributeValue(XSI_NS, "nil");
        if ("true".equals(value)) {
            result = true;
        }

        return result;
    }

    public String getPITarget() throws IllegalStateException {
        return XmlPullUtil.getPITarget(pp);
    }

    public String getPIData() throws IllegalStateException {
        return XmlPullUtil.getPIData(pp);
    }

    public boolean matches(int type, String namespace, String name)
        throws XmlPullParserException
    {
        return XmlPullUtil.matches(pp, type, namespace, name);
    }

    public void nextStartTag()
        throws XmlPullParserException, IOException
    {
        if(pp.nextTag() != XmlPullParser.START_TAG) {
            throw new XmlPullParserException(
                "expected START_TAG and not "+pp.getPositionDescription());
        }
    }

    public void nextStartTag(String name)
        throws XmlPullParserException, IOException
    {
        pp.nextTag();
        pp.require(XmlPullParser.START_TAG, null, name);
    }

    public void nextStartTag(String namespace, String name)
        throws XmlPullParserException, IOException
    {
        pp.nextTag();
        pp.require(XmlPullParser.START_TAG, namespace, name);
    }

    public void nextEndTag() throws XmlPullParserException, IOException {
        XmlPullUtil.nextEndTag(pp);
    }

    public void nextEndTag(String name)
        throws XmlPullParserException, IOException
    {
        XmlPullUtil.nextEndTag(pp, null, name);
    }

    public void nextEndTag(String namespace, String name)
        throws XmlPullParserException, IOException
    {
        XmlPullUtil.nextEndTag(pp, namespace, name);
    }

    public String nextText(String namespace, String name)
        throws IOException, XmlPullParserException
    {
        return XmlPullUtil.nextText(pp, namespace, name);
    }


    public void skipSubTree() throws XmlPullParserException, IOException {
        XmlPullUtil.skipSubTree(pp);
    }

    public double readDouble() throws XmlPullParserException, IOException {
        String value = pp.nextText();
        double d;
        try {
            d = Double.parseDouble(value);
        } catch(NumberFormatException ex) {
            if(value.equals("INF") || value.toLowerCase().equals("infinity")) {
                d = Double.POSITIVE_INFINITY;
            } else if (value.equals("-INF")
                       || value.toLowerCase().equals("-infinity")) {
                d = Double.NEGATIVE_INFINITY;
            } else if (value.equals("NaN")) {
                d = Double.NaN;
            } else {
                throw new XmlPullParserException("can't parse double value '"+value+"'", this, ex);
            }
        }
        return d;
    }

    public float readFloat() throws XmlPullParserException, IOException {
        String value = pp.nextText();
        float f;
        try {
            f = Float.parseFloat(value);
        } catch(NumberFormatException ex) {
            if(value.equals("INF") || value.toLowerCase().equals("infinity")) {
                f = Float.POSITIVE_INFINITY;
            } else if (value.equals("-INF")
                       || value.toLowerCase().equals("-infinity")) {
                f = Float.NEGATIVE_INFINITY;
            } else if (value.equals("NaN")) {
                f = Float.NaN;
            } else {
                throw new XmlPullParserException("can't parse float value '"+value+"'", this, ex);
            }
        }
        return f;
    }

    // method copied from JiBX see http://sourceforge.net/projects/jibx/ for details
    private int parseDigits(String text, int offset, int length)
        throws XmlPullParserException
    {

        // check if overflow a potential problem
        int value = 0;
        if (length > 9) {

            // use library parse code for potential overflow
            try {
                value = Integer.parseInt(text.substring(offset, offset+length));
            } catch (NumberFormatException ex) {
                throw new XmlPullParserException(ex.getMessage());
            }

        } else {

            // parse with no overflow worries
            int limit = offset + length;
            while (offset < limit) {
                char chr = text.charAt(offset++);
                if (chr >= '0' && chr <= '9') {
                    value = value * 10 + (chr - '0');
                } else {
                    throw new XmlPullParserException("non-digit in number value",this, null);
                }
            }

        }
        return value;
    }

    // method copied from JiBX see http://sourceforge.net/projects/jibx/ for details
    private int parseInt(String text) throws XmlPullParserException {

        // make sure there's text to be processed
        int offset = 0;
        int limit = text.length();
        if (limit == 0) {
            throw new XmlPullParserException("empty number value", this, null);
        }

        // check leading sign present in text
        boolean negate = false;
        char chr = text.charAt(0);
        if (chr == '-') {
            if (limit > 9) {

                // special case to make sure maximum negative value handled
                try {
                    return Integer.parseInt(text);
                } catch (NumberFormatException ex) {
                    throw new XmlPullParserException(ex.getMessage(), this, null);
                }

            } else {
                negate = true;
                offset++;
            }
        } else if (chr == '+') {
            offset++;
        }
        if (offset >= limit) {
            throw new XmlPullParserException("Invalid number format", this, null);
        }

        // handle actual value conversion
        int value = parseDigits(text, offset, limit-offset);
        if (negate) {
            return -value;
        } else {
            return value;
        }
    }

    public int readInt() throws XmlPullParserException, IOException {
        try {
            //int i = Integer.parseInt(pp.nextText());
            int i = parseInt(pp.nextText());
            return i;
        } catch(NumberFormatException ex) {
            throw new XmlPullParserException("can't parse int value", this, ex);
        }
    }

    public String readString() throws XmlPullParserException, IOException {
        String xsiNil = pp.getAttributeValue(XSD_NS, "nil");
        if("true".equals(xsiNil)) {
            nextEndTag();
            return null;
        }
        return pp.nextText();
    }

    public double readDoubleElement(String namespace, String name)
        throws XmlPullParserException, IOException
    {
        pp.require(XmlPullParser.START_TAG, namespace, name);
        return readDouble();
    }

    public float readFloatElement(String namespace, String name)
        throws XmlPullParserException, IOException
    {
        pp.require(XmlPullParser.START_TAG, namespace, name);
        return readFloat();
    }

    public int readIntElement(String namespace, String name)
        throws XmlPullParserException, IOException
    {
        pp.require(XmlPullParser.START_TAG, namespace, name);
        return readInt();
    }

    public String readStringElemet(String namespace, String name)
        throws XmlPullParserException, IOException
    {
        pp.require(XmlPullParser.START_TAG, namespace, name);
        return readString();
    }

}