Example usage for javax.xml.stream.events Namespace getNamespaceURI

List of usage examples for javax.xml.stream.events Namespace getNamespaceURI

Introduction

In this page you can find the example usage for javax.xml.stream.events Namespace getNamespaceURI.

Prototype

public String getNamespaceURI();

Source Link

Document

Gets the uri bound to the prefix of this namespace

Usage

From source file:Main.java

public static void main(String[] args) throws Exception {
    XMLEventFactory eventFactory = XMLEventFactory.newInstance();
    XMLEventWriter writer = XMLOutputFactory.newInstance().createXMLEventWriter(System.out);

    Namespace ns1 = eventFactory.createNamespace("ns1", "http://www.e.com/ns1");
    Namespace ns2 = eventFactory.createNamespace("ns2", "http://www.e.com/ns2");
    List<Namespace> namespaceList = new ArrayList<Namespace>();
    namespaceList.add(ns1);//from w w w  .jav  a 2 s .  c  o  m
    namespaceList.add(ns2);

    Attribute attribute = eventFactory.createAttribute(ns2.getPrefix(), ns2.getNamespaceURI(), "attribute",
            "true");

    writer.add(eventFactory.createStartElement(ns1.getPrefix(), ns1.getNamespaceURI(), "sample",
            Collections.singletonList(attribute).iterator(), namespaceList.iterator()));
    writer.add(eventFactory.createEndDocument());
    writer.flush();
}

From source file:com.amalto.core.load.io.XMLStreamUnwrapper.java

/**
 * Moves to next record in stream and stores it in {@link #stringWriter}.
 *///  w  ww. jav  a2s.co m
private void moveToNext() {
    try {
        XMLStreamWriter writer = xmlOutputFactory.createXMLStreamWriter(stringWriter);
        boolean hasMadeChanges;
        do {
            if (!reader.hasNext()) {
                break;
            }
            hasMadeChanges = false; // Keep a state to skip line feeds
            final XMLEvent event = reader.nextEvent();
            if (event.isEndElement()) {
                level--;
            } else if (event.isStartElement()) {
                level++;
            } else if (event.isEndDocument()) {
                level--;
            }
            if (level >= RECORD_LEVEL) {
                if (event.isEndElement()) {
                    writer.writeEndElement();
                    hasMadeChanges = true;
                } else if (event.isStartElement()) {
                    final StartElement startElement = event.asStartElement();
                    final QName name = startElement.getName();
                    writer.writeStartElement(name.getNamespaceURI(), name.getLocalPart());
                    boolean isRecordRootElement = (RECORD_LEVEL == level - 1);
                    if (isRecordRootElement) {
                        for (int i = 0; i < rootNamespaceList.size(); i++) {
                            Namespace namespace = rootNamespaceList.get(i);
                            writer.writeNamespace(namespace.getPrefix(), namespace.getNamespaceURI());
                        }
                    }
                    // Declare namespaces (if any)
                    final Iterator elementNamespaces = startElement.getNamespaces();
                    while (elementNamespaces.hasNext()) {
                        Namespace elementNamespace = (Namespace) elementNamespaces.next();
                        if (isRecordRootElement) {
                            if (rootNamespaceList.size() > 0) {
                                for (int i = 0; i < rootNamespaceList.size(); i++) {
                                    Namespace namespace = rootNamespaceList.get(i);
                                    if (!namespace.getPrefix().equals(elementNamespace.getPrefix())
                                            || !namespace.getNamespaceURI()
                                                    .equals(elementNamespace.getNamespaceURI())) {
                                        writer.writeNamespace(elementNamespace.getPrefix(),
                                                elementNamespace.getNamespaceURI());
                                    }
                                }
                            } else {
                                writer.writeNamespace(elementNamespace.getPrefix(),
                                        elementNamespace.getNamespaceURI());
                            }
                        } else {
                            writer.writeNamespace(elementNamespace.getPrefix(),
                                    elementNamespace.getNamespaceURI());
                        }
                    }
                    // Write attributes
                    final Iterator attributes = startElement.getAttributes();
                    while (attributes.hasNext()) {
                        Attribute attribute = (Attribute) attributes.next();
                        QName attributeName = attribute.getName();
                        String value = attribute.getValue();
                        if (StringUtils.isEmpty(attributeName.getNamespaceURI())) {
                            writer.writeAttribute(attributeName.getLocalPart(), value);
                        } else {
                            writer.writeAttribute(attributeName.getNamespaceURI(), attributeName.getLocalPart(),
                                    value);
                        }
                    }
                    hasMadeChanges = true;
                } else if (event.isCharacters()) {
                    final String text = event.asCharacters().getData().trim();
                    if (!text.isEmpty()) {
                        writer.writeCharacters(text);
                        hasMadeChanges = true;
                    }
                }
            }
        } while (level > RECORD_LEVEL || !hasMadeChanges);
        writer.flush();
    } catch (XMLStreamException e) {
        throw new RuntimeException("Unexpected parsing exception.", e);
    }
}

From source file:com.streamsets.pipeline.lib.xml.StreamingXmlParser.java

Map<String, Field> toField(StartElement startE) {
    Map<String, Field> map = new LinkedHashMap<>();
    Iterator attrs = startE.getAttributes();
    while (attrs.hasNext()) {
        Attribute attr = (Attribute) attrs.next();
        map.put(getName(ATTR_PREFIX_KEY, attr), Field.create(attr.getValue()));
    }//w  w  w  .j  a  va2s .  c o m
    Iterator nss = startE.getNamespaces();
    while (nss.hasNext()) {
        Namespace ns = (Namespace) nss.next();
        map.put(getName(NS_PREFIX_KEY, ns), Field.create(ns.getNamespaceURI()));
    }
    return map;
}

From source file:com.streamsets.pipeline.lib.xml.StreamingXmlParser.java

@SuppressWarnings("unchecked")
Field parse(XMLEventReader reader, StartElement startE) throws XMLStreamException, ObjectLengthException {
    Map<String, Field> map = this.useFieldAttributesInsteadOfFields ? new LinkedHashMap<>() : toField(startE);
    Map<String, Field> startEMap = map;
    Map<String, Object> contents = new LinkedHashMap<>();
    boolean maybeText = true;
    while (hasNext(reader) && !peek(reader).isEndElement()) {
        XMLEvent next = read(reader);
        if (next.isCharacters()) {
            // If this set of characters is all whitespace, ignore.
            if (next.asCharacters().isWhiteSpace()) {
                continue;
            } else if (peek(reader).isEndElement() && maybeText) {
                contents.put(VALUE_KEY, Field.create(((Characters) next).getData()));
            } else if (peek(reader).isStartElement()) {
                StartElement subStartE = (StartElement) read(reader);
                Field subField = parse(reader, subStartE);
                addContent(contents, getName(subStartE), subField);
                if (hasNext(reader) && peek(reader).isCharacters()) {
                    read(reader);//from  ww  w  .jav  a  2  s . c  om
                }
            } else if (maybeText) {
                throw new XMLStreamException(Utils
                        .format("Unexpected XMLEvent '{}', it should be START_ELEMENT or END_ELEMENT", next),
                        next.getLocation());
            }
        } else if (next.isStartElement()) {
            String name = getName((StartElement) next);
            Field field = parse(reader, (StartElement) next);
            addContent(contents, name, field);
        } else {
            throw new XMLStreamException(
                    Utils.format("Unexpected XMLEvent '{}', it should be START_ELEMENT or CHARACTERS", next),
                    next.getLocation());
        }
        maybeText = false;
    }
    if (hasNext(reader)) {
        EndElement endE = (EndElement) read(reader);
        if (!endE.getName().equals(startE.getName())) {
            throw new XMLStreamException(Utils.format("Unexpected EndElement '{}', it should be '{}'",
                    endE.getName().getLocalPart(), startE.getName().getLocalPart()), endE.getLocation());
        }
        for (Map.Entry<String, Object> entry : contents.entrySet()) {
            if (entry.getValue() instanceof Field) {
                startEMap.put(entry.getKey(), (Field) entry.getValue());
            } else {
                startEMap.put(entry.getKey(), Field.create((List<Field>) entry.getValue()));
            }
        }
    }
    final Field field = Field.create(startEMap);

    if (this.useFieldAttributesInsteadOfFields) {
        Iterator attrs = startE.getAttributes();
        while (attrs.hasNext()) {
            Attribute attr = (Attribute) attrs.next();
            field.setAttribute(getName(XMLATTR_ATTRIBUTE_PREFIX, attr), attr.getValue());
        }
        Iterator nss = startE.getNamespaces();
        while (nss.hasNext()) {
            Namespace ns = (Namespace) nss.next();
            field.setAttribute(getName(null, ns), ns.getNamespaceURI());
        }
    }

    lastParsedFieldXpathPrefix = getXpathPrefix();
    return field;
}

From source file:com.google.code.activetemplates.impl.TemplateCompilerImpl.java

private void doCompile(String name, CompileContext cc) throws XMLStreamException {

    while (cc.hasNextEvent()) {

        XMLEvent e = cc.nextEvent();

        //Location loc = e.getLocation();

        if (e.isAttribute()) {
            //System.out.println("Adding " + e);

            // attributes added during tag processing and under the same tag
            // get handled here, outcome is always PROCESS_ALL

            Attribute a = (Attribute) e;
            if (h.isAttributeHandled(a.getName())) {
                h.processAttribute(cc, a);
            } else {
                String value = a.getValue();
                String nvalue = processText(cc, value);
                if (nvalue != null) {
                    a = cc.getElementFactory().createAttribute(a.getName(), nvalue);
                }/*w  w w.j av a2  s . c  om*/
                //System.out.println("Adding " + e);
                cc.getWriter().add(a);
            }

        } else if (e.isStartElement()) {

            StartElement se = e.asStartElement();

            Processing processing = Processing.DEFAULT;

            // collect namespaces
            @SuppressWarnings("unchecked")
            Iterator<Namespace> nsit = se.getNamespaces();
            List<Namespace> namespaces = new ArrayList<Namespace>();

            while (nsit.hasNext()) {
                Namespace ns = nsit.next();
                if (excludedNamespaces.contains(ns.getNamespaceURI())) {
                    processing = Processing.REPLACE;
                } else {
                    namespaces.add(ns);
                }
            }

            // collect attributes
            @SuppressWarnings("unchecked")
            Iterator<Attribute> it = se.getAttributes();
            List<Attribute> attributes = new LinkedList<Attribute>();
            while (it.hasNext()) {
                attributes.add(it.next());
            }

            // collect any separate attribute and namespace xml events
            while (cc.hasNextEvent()) {
                if (cc.peekEvent().isNamespace()) {
                    namespaces.add((Namespace) cc.nextEvent());
                    processing = Processing.REPLACE;
                } else if (cc.peekEvent().isAttribute()) {
                    attributes.add((Attribute) cc.nextEvent());
                    processing = Processing.REPLACE;
                } else {
                    break;
                }
            }

            // preprocess attributes
            it = attributes.iterator();
            attributes = new ArrayList<Attribute>();

            while (it.hasNext() && processing != Processing.SKIP) {
                Attribute a = it.next();

                if (h.isAttributeHandled(a.getName())) {
                    processing = Processing.REPLACE;

                    AttributeHandler.Outcome o = h.processAttribute(cc, a);
                    if (o == Outcome.PROCESS_NONE) {
                        processing = Processing.SKIP;
                    }

                } else {
                    String value = a.getValue();
                    String nvalue = processText(cc, value);
                    if (nvalue != null) {
                        a = cc.getElementFactory().createAttribute(a.getName(), nvalue);
                        processing = Processing.REPLACE;
                    }

                    attributes.add(a);
                }
            }

            if (processing == Processing.SKIP) {

                skipChildren(cc, false);

            } else {

                if (processing == Processing.REPLACE) {
                    // replace element with new one
                    se = cc.getElementFactory().createStartElement(se.getName(), attributes.iterator(),
                            namespaces.iterator());
                }

                // handle start element
                if (h.isElementHandled(se.getName())) {
                    ElementHandler.Outcome o = h.processStartElement(cc, se);
                    cc.flushEventQueue();
                    switch (o) {
                    case PROCESS_SIBLINGS:
                        skipChildren(cc, true);
                        break;
                    }
                } else {
                    //System.out.println("Adding " + se);
                    cc.getWriter().add(se);
                    cc.flushEventQueue(); // flush events added by any attribute handlers
                }
            }

        } else if (e.isEndElement()) {

            // handle end element
            if (h.isElementHandled(e.asEndElement().getName())) {
                h.processEndElement(cc, e.asEndElement());
                cc.flushEventQueue();
            } else {
                //System.out.println("Adding " + e);
                cc.getWriter().add(e);
            }

        } else if (e.isCharacters()) {

            // process text
            Characters ce = e.asCharacters();
            String s = ce.getData();
            String ns = processText(cc, s);
            if (ns != null) {
                ce = cc.getElementFactory().createCharacters(ns);
            }
            //System.out.println("Adding " + e);
            cc.getWriter().add(ce);

        }

    }

}

From source file:ca.uhn.fhir.parser.XmlParser.java

private void encodeXhtml(XhtmlDt theDt, XMLStreamWriter theEventWriter) throws XMLStreamException {
    if (theDt == null || theDt.getValue() == null) {
        return;/*from   www  . j  a va  2s  .  co  m*/
    }

    boolean firstElement = true;
    for (XMLEvent event : theDt.getValue()) {
        switch (event.getEventType()) {
        case XMLStreamConstants.ATTRIBUTE:
            Attribute attr = (Attribute) event;
            if (isBlank(attr.getName().getPrefix())) {
                if (isBlank(attr.getName().getNamespaceURI())) {
                    theEventWriter.writeAttribute(attr.getName().getLocalPart(), attr.getValue());
                } else {
                    theEventWriter.writeAttribute(attr.getName().getNamespaceURI(),
                            attr.getName().getLocalPart(), attr.getValue());
                }
            } else {
                theEventWriter.writeAttribute(attr.getName().getPrefix(), attr.getName().getNamespaceURI(),
                        attr.getName().getLocalPart(), attr.getValue());
            }

            break;
        case XMLStreamConstants.CDATA:
            theEventWriter.writeCData(((Characters) event).getData());
            break;
        case XMLStreamConstants.CHARACTERS:
        case XMLStreamConstants.SPACE:
            String data = ((Characters) event).getData();
            theEventWriter.writeCharacters(data);
            break;
        case XMLStreamConstants.COMMENT:
            theEventWriter.writeComment(((Comment) event).getText());
            break;
        case XMLStreamConstants.END_ELEMENT:
            theEventWriter.writeEndElement();
            break;
        case XMLStreamConstants.ENTITY_REFERENCE:
            EntityReference er = (EntityReference) event;
            theEventWriter.writeEntityRef(er.getName());
            break;
        case XMLStreamConstants.NAMESPACE:
            Namespace ns = (Namespace) event;
            theEventWriter.writeNamespace(ns.getPrefix(), ns.getNamespaceURI());
            break;
        case XMLStreamConstants.START_ELEMENT:
            StartElement se = event.asStartElement();
            if (firstElement) {
                if (StringUtils.isBlank(se.getName().getPrefix())) {
                    String namespaceURI = se.getName().getNamespaceURI();
                    if (StringUtils.isBlank(namespaceURI)) {
                        namespaceURI = "http://www.w3.org/1999/xhtml";
                    }
                    theEventWriter.writeStartElement(se.getName().getLocalPart());
                    theEventWriter.writeDefaultNamespace(namespaceURI);
                } else {
                    String prefix = se.getName().getPrefix();
                    String namespaceURI = se.getName().getNamespaceURI();
                    theEventWriter.writeStartElement(prefix, se.getName().getLocalPart(), namespaceURI);
                    theEventWriter.writeNamespace(prefix, namespaceURI);
                }
                firstElement = false;
            } else {
                if (isBlank(se.getName().getPrefix())) {
                    if (isBlank(se.getName().getNamespaceURI())) {
                        theEventWriter.writeStartElement(se.getName().getLocalPart());
                    } else {
                        if (StringUtils.isBlank(se.getName().getPrefix())) {
                            theEventWriter.writeStartElement(se.getName().getLocalPart());
                            // theEventWriter.writeDefaultNamespace(se.getName().getNamespaceURI());
                        } else {
                            theEventWriter.writeStartElement(se.getName().getNamespaceURI(),
                                    se.getName().getLocalPart());
                        }
                    }
                } else {
                    theEventWriter.writeStartElement(se.getName().getPrefix(), se.getName().getLocalPart(),
                            se.getName().getNamespaceURI());
                }
                for (Iterator<?> attrIter = se.getAttributes(); attrIter.hasNext();) {
                    Attribute next = (Attribute) attrIter.next();
                    theEventWriter.writeAttribute(next.getName().getLocalPart(), next.getValue());
                }
            }
            break;
        case XMLStreamConstants.DTD:
        case XMLStreamConstants.END_DOCUMENT:
        case XMLStreamConstants.ENTITY_DECLARATION:
        case XMLStreamConstants.NOTATION_DECLARATION:
        case XMLStreamConstants.PROCESSING_INSTRUCTION:
        case XMLStreamConstants.START_DOCUMENT:
            break;
        }

    }
}

From source file:nl.nn.adapterframework.validation.XSD.java

public void init() throws ConfigurationException {
    if (noNamespaceSchemaLocation != null) {
        url = ClassUtils.getResourceURL(classLoader, noNamespaceSchemaLocation);
        if (url == null) {
            throw new ConfigurationException("Cannot find [" + noNamespaceSchemaLocation + "]");
        }/*from  ww w  .  j a  v  a2 s .  c  om*/
        resourceTarget = noNamespaceSchemaLocation;
        toString = noNamespaceSchemaLocation;
    } else {
        if (resource != null) {
            url = ClassUtils.getResourceURL(classLoader, resource);
            if (url == null) {
                throw new ConfigurationException("Cannot find [" + resource + "]");
            }
            resourceTarget = resource;
            toString = resource;
            if (resourceInternalReference != null) {
                resourceTarget = resourceTarget + "-" + resourceInternalReference + ".xsd";
                toString = toString + "!" + resourceInternalReference;
            }
        } else if (sourceXsds == null) {
            throw new ConfigurationException(
                    "None of noNamespaceSchemaLocation, resource or mergedResources is specified");
        } else {
            resourceTarget = "[";
            toString = "[";
            boolean first = true;
            for (XSD xsd : sourceXsds) {
                if (first) {
                    first = false;
                } else {
                    resourceTarget = resourceTarget + ", ";
                    toString = toString + ", ";
                }
                resourceTarget = resourceTarget + xsd.getResourceTarget().replaceAll("/", "_");
                toString = toString + xsd.toString();
            }
            resourceTarget = resourceTarget + "].xsd";
            toString = toString + "]";
        }
        if (parentLocation == null) {
            this.parentLocation = "";
        }
    }
    try {
        InputStream in = getInputStream();
        XMLEventReader er = XmlUtils.INPUT_FACTORY.createXMLEventReader(in, XmlUtils.STREAM_FACTORY_ENCODING);
        int elementDepth = 0;
        while (er.hasNext()) {
            XMLEvent e = er.nextEvent();
            switch (e.getEventType()) {
            case XMLStreamConstants.START_ELEMENT:
                elementDepth++;
                StartElement el = e.asStartElement();
                if (el.getName().equals(SchemaUtils.SCHEMA)) {
                    Attribute a = el.getAttributeByName(SchemaUtils.TNS);
                    if (a != null) {
                        xsdTargetNamespace = a.getValue();
                    }
                    Iterator<Namespace> nsIterator = el.getNamespaces();
                    while (nsIterator.hasNext() && StringUtils.isEmpty(xsdDefaultNamespace)) {
                        Namespace ns = nsIterator.next();
                        if (StringUtils.isEmpty(ns.getPrefix())) {
                            xsdDefaultNamespace = ns.getNamespaceURI();
                        }
                    }
                } else if (el.getName().equals(SchemaUtils.IMPORT)) {
                    Attribute a = el.getAttributeByName(SchemaUtils.NAMESPACE);
                    if (a != null) {
                        boolean skip = false;
                        ArrayList ans = null;
                        if (StringUtils.isNotEmpty(getImportedNamespacesToIgnore())) {
                            ans = new ArrayList(Arrays.asList(getImportedNamespacesToIgnore().split(",")));
                        }
                        if (StringUtils.isNotEmpty(a.getValue()) && ans != null) {
                            if (ans.contains(a.getValue())) {
                                skip = true;
                            }
                        }
                        if (!skip) {
                            importedNamespaces.add(a.getValue());
                        }
                    }
                } else if (el.getName().equals(SchemaUtils.ELEMENT)) {
                    if (elementDepth == 2) {
                        rootTags.add(el.getAttributeByName(SchemaUtils.NAME).getValue());
                    }
                }
                break;
            case XMLStreamConstants.END_ELEMENT:
                elementDepth--;
                break;
            }
        }
        this.targetNamespace = xsdTargetNamespace;
        if (namespace == null) {
            // In case WsdlXmlValidator doesn't have schemaLocation
            namespace = xsdTargetNamespace;
        }
    } catch (IOException e) {
        String message = "IOException reading XSD";
        LOG.error(message, e);
        throw new ConfigurationException(message, e);
    } catch (XMLStreamException e) {
        String message = "XMLStreamException reading XSD";
        LOG.error(message, e);
        throw new ConfigurationException(message, e);
    }
}

From source file:org.apache.hadoop.gateway.filter.rewrite.impl.xml.XmlFilterReader.java

private void bufferNamespaces(StartElement event, Element element) {
    Iterator namespaces = event.getNamespaces();
    while (namespaces.hasNext()) {
        Namespace namespace = (Namespace) namespaces.next();
        if (namespace.isDefaultNamespaceDeclaration()) {
            element.setAttribute("xmlns", namespace.getNamespaceURI());
        } else {//w  ww  . j a v a 2s .c  o m
            element.setAttribute("xmlns:" + namespace.getPrefix(), namespace.getNamespaceURI());
        }
    }
}

From source file:org.apache.hadoop.gateway.filter.rewrite.impl.xml.XmlFilterReader.java

private void streamNamespaces(StartElement event) {
    Iterator i = event.getNamespaces();
    while (i.hasNext()) {
        Namespace ns = (Namespace) i.next();
        writer.write(" xmlns");
        if (!ns.isDefaultNamespaceDeclaration()) {
            writer.write(":");
            writer.write(ns.getPrefix());
        }/*from www . ja v a  2  s  . com*/
        writer.write("=\"");
        writer.write(ns.getNamespaceURI());
        writer.write("\"");
    }
}

From source file:org.codice.ddf.spatial.ogc.wfs.transformer.handlebars.HandlebarsWfsFeatureTransformer.java

private void mapNamespaces(StartElement startElement, Map<String, String> map) {

    for (Iterator i = startElement.getNamespaces(); i.hasNext();) {
        Namespace namespace = (Namespace) i.next();
        map.put(namespace.getPrefix(), namespace.getNamespaceURI());
    }//from www  .j a  v  a  2 s  . c o m
}