XPathNavigator.java

package eu.fbk.knowledgestore.data;

import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

import javax.annotation.Nullable;

import com.google.common.collect.AbstractIterator;
import com.google.common.collect.Iterators;
import com.google.common.collect.UnmodifiableIterator;

import org.jaxen.DefaultNavigator;
import org.jaxen.UnsupportedAxisException;
import org.jaxen.saxpath.SAXPathException;
import org.openrdf.model.Statement;
import org.openrdf.model.URI;
import org.openrdf.model.Value;

final class XPathNavigator extends DefaultNavigator {

    public static final XPathNavigator INSTANCE = new XPathNavigator();

    private static final long serialVersionUID = -1402394846594186887L;

    private XPathNavigator() {
    }

    public Object wrap(final Object node) {
        return new Element(null, null, node);
    }

    public Object unwrap(final Object object) {
        return object instanceof Element ? ((Element) object).getContent() : object;
    }

    @Override
    public Iterator<?> getChildAxisIterator(final Object contextNode)
            throws UnsupportedAxisException {

        if (contextNode instanceof Element) {
            final Element element = (Element) contextNode;
            if (element.getContent() instanceof Record) {
                return new ChildIterator(element);
            } else {
                final Object value = element.getContent();
                return Iterators.singletonIterator(value instanceof Number || //
                        value instanceof Boolean ? value : value.toString());
            }
        } else {
            return Collections.emptyIterator();
        }
    }

    @Override
    public Iterator<?> getParentAxisIterator(final Object contextNode)
            throws UnsupportedAxisException {
        return contextNode instanceof Element ? new ParentIterator((Element) contextNode)
                : Collections.emptyIterator();
    }

    @Override
    public Object getParentNode(final Object child) throws UnsupportedAxisException {
        return child instanceof Element ? ((Element) child).getParent() : null;
    }

    @Override
    public Object getDocumentNode(final Object contextNode) {
        if (!(contextNode instanceof Element)) {
            return null;
        }
        Element element = (Element) contextNode;
        while (element.getParent() != null) {
            element = element.getParent();
            assert element != null;
        }
        return element;
    }

    @Override
    public String translateNamespacePrefixToUri(final String prefix, final Object element) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getElementNamespaceUri(final Object element) {
        if (element instanceof Element) {
            final URI tag = ((Element) element).getTag();
            return tag == null ? "" : tag.getNamespace();
        }
        return null;
    }

    @Override
    public String getElementName(final Object element) {
        if (element instanceof Element) {
            final URI tag = ((Element) element).getTag();
            return tag == null ? "" : tag.getLocalName();
        }
        return null;
    }

    @Override
    public String getElementQName(final Object element) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getAttributeNamespaceUri(final Object attr) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getAttributeName(final Object attr) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getAttributeQName(final Object attr) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public boolean isDocument(final Object object) {
        return object instanceof Element && ((Element) object).getParent() == null;
    }

    @Override
    public boolean isElement(final Object object) {
        return object instanceof Element && ((Element) object).getParent() != null;
    }

    @Override
    public boolean isAttribute(final Object object) {
        return false;
    }

    @Override
    public boolean isNamespace(final Object object) {
        return false;
    }

    @Override
    public boolean isComment(final Object object) {
        return false;
    }

    @Override
    public boolean isText(final Object object) {
        return !(object instanceof Element) && !(object instanceof Collection);
    }

    @Override
    public boolean isProcessingInstruction(final Object object) {
        return false;
    }

    @Override
    public String getCommentStringValue(final Object comment) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getElementStringValue(final Object element) {
        if (element instanceof Element) {
            final Object object = ((Element) element).getContent();
            if (object instanceof Record) {
                return "";
            } else if (object instanceof Value) {
                return ((Value) object).stringValue();
            } else if (object instanceof Statement) {
                return object.toString();
            }
        }
        return null;
    }

    @Override
    public String getAttributeStringValue(final Object attr) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getNamespaceStringValue(final Object ns) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public String getTextStringValue(final Object text) {
        if (text instanceof Element || text instanceof Collection) {
            return null;
        }
        if (text instanceof Value) {
            return ((Value) text).stringValue();
        }
        return text.toString();
    }

    @Override
    public String getNamespacePrefix(final Object ns) {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    @Override
    public org.jaxen.XPath parseXPath(final String xpath) throws SAXPathException {
        throw new Error("This method is not expected to be called by Jaxen (!)");
    }

    private static final class ParentIterator extends UnmodifiableIterator<Object> {

        private final Element node;

        ParentIterator(final Element node) {
            assert node != null;
            this.node = node;
        }

        @Override
        public boolean hasNext() {
            return this.node.getParent() != null;
        }

        @Override
        public Element next() {
            final Element parent = this.node.getParent();
            if (parent == null) {
                throw new NoSuchElementException();
            }
            return parent;
        }

    }

    private static final class ChildIterator extends AbstractIterator<Object> {

        private final Element parent;

        private final List<URI> properties;

        private URI propertyURI;

        private int propertyIndex;

        private List<? extends Object> values;

        private int valueIndex;

        public ChildIterator(final Element parent) {

            assert parent != null;
            assert parent.getContent() instanceof Record;

            this.parent = parent;
            this.properties = ((Record) parent.getContent()).getProperties();
            this.propertyURI = null;
            this.propertyIndex = 0;
            this.values = Collections.emptyList();
            this.valueIndex = 0;
        }

        @Override
        protected Object computeNext() {
            while (true) {
                while (this.valueIndex < this.values.size()) {
                    final Object value = this.values.get(this.valueIndex++);
                    // if (!BooleanLiteralImpl.FALSE.equals(value)) {
                    // This is necessary for proper comparison of boolean values
                    return new Element(this.parent, this.propertyURI, value);
                    // }
                }
                if (this.propertyIndex == this.properties.size()) {
                    return endOfData();
                }
                this.propertyURI = this.properties.get(this.propertyIndex++);
                this.values = ((Record) this.parent.getContent()).get(this.propertyURI);
                this.valueIndex = 0;
            }
        }

    }

    private static final class Element {

        @Nullable
        private final Element parent;

        @Nullable
        private final URI tag;

        private final Object content;

        public Element(@Nullable final Element parent, @Nullable final URI tag, //
                final Object content) {
            this.parent = parent;
            this.tag = tag;
            this.content = content;
        }

        @Nullable
        public Element getParent() {
            return this.parent;
        }

        @Nullable
        public URI getTag() {
            return this.tag;
        }

        public Object getContent() {
            return this.content;
        }

    }

}