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

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

  1. HOME
  2. Java
  3. javax
  4. javax.xml.stream.events.*
  5. Namespace
  6. getPrefix

Introduction

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

Prototype

public String getPrefix();

Source Link

Document

Gets the prefix, returns "" if this is a default namespace declaration.

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 .j a  v  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  .  j  a v  a2  s . c  o 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:org.javelin.sws.ext.bind.internal.model.AttributePattern.java

@Override
protected void replayNonNullString(String value, XMLEventWriter eventWriter, MarshallingContext context)
        throws XMLStreamException {
    if (!XMLConstants.NULL_NS_URI.equals(this.attributeName.getNamespaceURI())) {
        // we MUST create second namespace declaration if the current one has default ("") prefix, otherwise the attribute will have absent
        // namespace!
        // see: http://www.w3.org/TR/xml-names11/#defaulting - "The namespace name for an unprefixed attribute name always has no value."
        String prefix = this.safeRegisterNamespace(context, eventWriter, this.attributeName);
        if (XMLConstants.DEFAULT_NS_PREFIX.equals(prefix)) {
            Namespace namespace = this.safePrepareNamespace(
                    context, eventWriter, new QName(this.attributeName.getNamespaceURI(),
                            this.attributeName.getLocalPart(), context.newPrefix()),
                    NamespaceRegistration.IF_DEFAULT_PREFIX);
            prefix = namespace.getPrefix();
        }/*from  w  w w.j  a va2 s .  c  om*/
        eventWriter.add(XML_EVENTS_FACTORY.createAttribute(prefix, this.attributeName.getNamespaceURI(),
                this.attributeName.getLocalPart(), value));
    } else {
        // attribute is unqalified and has no namespace
        eventWriter.add(XML_EVENTS_FACTORY.createAttribute(this.attributeName.getLocalPart(), value));
    }
}

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   ww  w.  j a  v a  2  s.  com*/
    }

    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  w w w. j  av  a 2s  . 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 {//from  w  w w .j  a  va2 s . c om
            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());
        }/* ww w .ja v  a  2  s  .  c  o m*/
        writer.write("=\"");
        writer.write(ns.getNamespaceURI());
        writer.write("\"");
    }
}

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

private boolean isPrefixBound(StartElement startElement, String prefix) {
    for (Iterator i = startElement.getNamespaces(); i.hasNext();) {
        Namespace namespace = (Namespace) i.next();

        if (namespace.getPrefix().equals(prefix)) {
            return true;
        }/*from  w w w .jav  a2 s  .  com*/
    }
    return false;
}

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());
    }// ww  w.  j a v  a  2  s  .  c o  m
}

From source file:org.pentaho.di.trans.steps.xmlinputstream.XMLInputStream.java

@SuppressWarnings("unchecked")
private Object[] parseNamespaces(Object[] outputRowData, XMLEvent e)
        throws KettleValueException, KettleStepException {
    Iterator<Namespace> iter = e.asStartElement().getNamespaces();
    if (iter.hasNext()) {
        Object[] outputRowDataNamespace = data.outputRowMeta.cloneRow(outputRowData);
        putRowOut(outputRowDataNamespace); // first put the element name info out
        // change data_type to ATTRIBUTE
        if (data.pos_xml_data_type_numeric != -1) {
            outputRowData[data.pos_xml_data_type_numeric] = new Long(XMLStreamConstants.NAMESPACE);
        }//  w w w .j a va 2  s  .c  om
        if (data.pos_xml_data_type_description != -1) {
            outputRowData[data.pos_xml_data_type_description] = eventDescription[XMLStreamConstants.NAMESPACE];
        }
    }
    while (iter.hasNext()) {
        Object[] outputRowDataNamespace = data.outputRowMeta.cloneRow(outputRowData);
        Namespace n = iter.next();
        outputRowDataNamespace[data.pos_xml_data_name] = n.getPrefix();
        outputRowDataNamespace[data.pos_xml_data_value] = n.getNamespaceURI();
        if (iter.hasNext()) {
            // send out the Namespace row
            putRowOut(outputRowDataNamespace);
        } else {
            // last row: this will be sent out by the outer loop
            outputRowData = outputRowDataNamespace;
        }
    }

    return outputRowData;
}