Example usage for javax.xml.stream XMLStreamConstants CDATA

List of usage examples for javax.xml.stream XMLStreamConstants CDATA

  1. HOME
  2. Java
  3. javax
  4. javax.xml.stream.*
  5. XMLStreamConstants
  6. CDATA

Introduction

In this page you can find the example usage for javax.xml.stream XMLStreamConstants CDATA.

Prototype

int CDATA

To view the source code for javax.xml.stream XMLStreamConstants CDATA.

Click Source Link

Document

Indicates an event is a CDATA section

Usage

From source file:org.apache.synapse.commons.json.JsonDataSource.java

public void serialize(XMLStreamWriter xmlWriter) throws XMLStreamException {
    XMLStreamReader reader = getReader();
    xmlWriter.writeStartDocument();// w  ww.  j av a  2  s.  com
    while (reader.hasNext()) {
        int x = reader.next();
        switch (x) {
        case XMLStreamConstants.START_ELEMENT:
            xmlWriter.writeStartElement(reader.getPrefix(), reader.getLocalName(), reader.getNamespaceURI());
            int namespaceCount = reader.getNamespaceCount();
            for (int i = namespaceCount - 1; i >= 0; i--) {
                xmlWriter.writeNamespace(reader.getNamespacePrefix(i), reader.getNamespaceURI(i));
            }
            int attributeCount = reader.getAttributeCount();
            for (int i = 0; i < attributeCount; i++) {
                xmlWriter.writeAttribute(reader.getAttributePrefix(i), reader.getAttributeNamespace(i),
                        reader.getAttributeLocalName(i), reader.getAttributeValue(i));
            }
            break;
        case XMLStreamConstants.START_DOCUMENT:
            break;
        case XMLStreamConstants.CHARACTERS:
            xmlWriter.writeCharacters(reader.getText());
            break;
        case XMLStreamConstants.CDATA:
            xmlWriter.writeCData(reader.getText());
            break;
        case XMLStreamConstants.END_ELEMENT:
            xmlWriter.writeEndElement();
            break;
        case XMLStreamConstants.END_DOCUMENT:
            xmlWriter.writeEndDocument();
            break;
        case XMLStreamConstants.SPACE:
            break;
        case XMLStreamConstants.COMMENT:
            xmlWriter.writeComment(reader.getText());
            break;
        case XMLStreamConstants.DTD:
            xmlWriter.writeDTD(reader.getText());
            break;
        case XMLStreamConstants.PROCESSING_INSTRUCTION:
            xmlWriter.writeProcessingInstruction(reader.getPITarget(), reader.getPIData());
            break;
        case XMLStreamConstants.ENTITY_REFERENCE:
            xmlWriter.writeEntityRef(reader.getLocalName());
            break;
        default:
            throw new OMException();
        }
    }
    xmlWriter.writeEndDocument();
    xmlWriter.flush();
    xmlWriter.close();
}

From source file:org.apache.synapse.config.xml.EntrySerializer.java

/**
 * Serialize the Entry object to an OMElement representing the entry
 *
 * @param entry//from w  w  w  . jav a 2  s.  c  om
 * @param parent
 * @return OMElement representing the entry
 */
public static OMElement serializeEntry(Entry entry, OMElement parent) {
    String customFactory = SynapsePropertiesLoader.getPropertyValue("synapse.entry.serializer", "");
    if (customFactory != null && !"".equals(customFactory)) {
        try {
            Class c = Class.forName(customFactory);
            Object o = c.newInstance();
            if (o instanceof IEntrySerializer) {
                return ((IEntrySerializer) o).serializeEntry(entry, parent);
            }
        } catch (ClassNotFoundException e) {
            handleException("Class specified by the synapse.entry.factory " + "synapse property not found: "
                    + customFactory, e);
        } catch (InstantiationException e) {
            handleException("Class specified by the synapse.entry.factory "
                    + "synapse property cannot be instantiated: " + customFactory, e);
        } catch (IllegalAccessException e) {
            handleException("Class specified by the synapse.entry.factory "
                    + "synapse property cannot be accessed: " + customFactory, e);
        }
    }

    OMElement entryElement = fac.createOMElement("localEntry", synNS);

    entryElement.addAttribute(fac.createOMAttribute("key", nullNS, entry.getKey().trim()));
    int type = entry.getType();
    if (type == Entry.URL_SRC) {
        URL srcUrl = entry.getSrc();
        if (srcUrl != null) {
            entryElement.addAttribute(fac.createOMAttribute("src", nullNS, srcUrl.toString().trim()));
        }
    } else if (type == Entry.INLINE_XML) {
        Object value = entry.getValue();
        if (value != null && value instanceof OMElement) {
            entryElement.addChild((OMElement) value);
        }
    } else if (type == Entry.INLINE_TEXT) {
        Object value = entry.getValue();
        if (value != null && value instanceof String) {
            OMTextImpl textData = (OMTextImpl) fac.createOMText(((String) value).trim());
            textData.setType(XMLStreamConstants.CDATA);
            entryElement.addChild(textData);
        }
    } else if (type == Entry.REMOTE_ENTRY) {
        // nothing to serialize
        return null;
    } else {
        handleException("Entry type undefined");
    }

    if (entry.getDescription() != null) {
        OMElement descriptionElem = fac
                .createOMElement(new QName(XMLConfigConstants.SYNAPSE_NAMESPACE, "description"), entryElement);
        descriptionElem.setText(entry.getDescription());
        entryElement.addChild(descriptionElem);
    }

    if (parent != null) {
        parent.addChild(entryElement);
    }
    return entryElement;
}

From source file:org.apache.synapse.config.xml.PropertySerializer.java

/**
 * Serialize the Property object to an OMElement representing the property
 * @param property//from  w  ww  .  ja  va  2 s.  c o m
 * @param parent
 * @return OMElement representing the property
 */
public static OMElement serializeProperty(Property property, OMElement parent) {

    OMElement propertyElement = fac.createOMElement("set-property", synNS);
    propertyElement.addAttribute(fac.createOMAttribute("name", nullNS, property.getName()));
    //       propertyElement.addAttribute(fac.createOMAttribute(
    //                "type", nullNS, "" + property.getType()));

    if (property.getType() == Property.DYNAMIC_TYPE) {
        propertyElement.addAttribute(fac.createOMAttribute("key", nullNS, property.getKey()));
    } else if (property.getType() == Property.SRC_TYPE) {
        propertyElement.addAttribute(fac.createOMAttribute("src", nullNS, property.getSrc().toString()));
    } else if (property.getType() == Property.VALUE_TYPE) {
        propertyElement.addAttribute(fac.createOMAttribute("value", nullNS, (String) property.getValue()));
    } else if (property.getType() == Property.INLINE_XML_TYPE) {
        propertyElement.addChild((OMElement) property.getValue());
    } else if (property.getType() == Property.INLINE_STRING_TYPE) {
        OMTextImpl textData = (OMTextImpl) fac.createOMText((String) property.getValue());
        textData.setType(XMLStreamConstants.CDATA);
        propertyElement.addChild(textData);
    } else {
        handleException("Property type undefined");
    }
    if (parent != null) {
        parent.addChild(propertyElement);
    }
    return propertyElement;
}

From source file:org.apereo.portal.xml.stream.IndentingXMLEventWriter.java

@Override
public void add(XMLEvent event) throws XMLStreamException {
    switch (event.getEventType()) {
    case XMLStreamConstants.CHARACTERS:
    case XMLStreamConstants.CDATA:
    case XMLStreamConstants.SPACE: {
        wrappedWriter.add(event);/*from ww w.j  ava  2 s .  c  o  m*/
        afterData();
        return;
    }
    case XMLStreamConstants.START_ELEMENT: {
        beforeStartElement();
        wrappedWriter.add(event);
        afterStartElement();
        return;
    }

    case XMLStreamConstants.END_ELEMENT: {
        beforeEndElement();
        wrappedWriter.add(event);
        afterEndElement();
        return;
    }
    case XMLStreamConstants.START_DOCUMENT:
    case XMLStreamConstants.PROCESSING_INSTRUCTION:
    case XMLStreamConstants.COMMENT:
    case XMLStreamConstants.DTD: {
        beforeMarkup();
        wrappedWriter.add(event);
        afterMarkup();
        return;
    }
    case XMLStreamConstants.END_DOCUMENT: {
        wrappedWriter.add(event);
        afterEndDocument();
        break;
    }
    default: {
        wrappedWriter.add(event);
        return;
    }
    }
}

From source file:org.openanzo.services.serialization.XMLBackupReader.java

/**
 * Parse the data within the reader, passing the results to the IRepositoryHandler
 * /*from w ww  . j ava 2  s .co  m*/
 * @param reader
 *            reader containing the data
 * @param handler
 *            Handler which will handle the elements within the data
 * @throws AnzoException
 */
private void parseBackup(Reader reader, final IBackupHandler handler) throws AnzoException {
    try {
        XMLStreamReader parser = XMLFactoryFinder.getXMLInputFactory().createXMLStreamReader(reader);

        for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {
            switch (event) {
            case XMLStreamConstants.START_ELEMENT:
                if (SerializationConstants.namedGraph.equals(parser.getLocalName())) {
                    graphUri = parser.getAttributeValue(null, SerializationConstants.namedGraphUri);
                    String meta = parser.getAttributeValue(null, SerializationConstants.metadataGraphUri);
                    String uuidString = parser.getAttributeValue(null, SerializationConstants.namedGraphUUID);
                    namedGraphUri = Constants.valueFactory.createURI(graphUri);
                    metaURI = Constants.valueFactory.createURI(meta);
                    uuid = Constants.valueFactory.createURI(uuidString);
                    revisioned = Boolean
                            .parseBoolean(parser.getAttributeValue(null, SerializationConstants.revisioned));
                } else if (SerializationConstants.revisions.equals(parser.getLocalName())) {
                    revisions = new ArrayList<BackupRevision>();
                } else if (SerializationConstants.revisionInfo.equals(parser.getLocalName())) {
                    long revision = Long
                            .parseLong(parser.getAttributeValue(null, SerializationConstants.revision));
                    Long start = Long.valueOf(parser.getAttributeValue(null, SerializationConstants.start));
                    String endString = parser.getAttributeValue(null, SerializationConstants.end);
                    Long end = (endString != null) ? Long.valueOf(endString) : -1;
                    lastModified = Constants.valueFactory
                            .createURI(parser.getAttributeValue(null, SerializationConstants.lastModifiedBy));
                    revisions.add(new BackupRevision(revision, start, end, lastModified));
                } else if (SerializationConstants.statement.equals(parser.getLocalName())) {
                    if (processGraph) {
                        if (revisioned) {
                            String startString = parser.getAttributeValue(null, SerializationConstants.start);
                            String endString = parser.getAttributeValue(null, SerializationConstants.end);
                            if (startString != null)
                                start = Long.valueOf(startString);
                            if (endString != null)
                                end = Long.valueOf(endString);
                        }
                    }
                } else if (SerializationConstants.statements.equals(parser.getLocalName())) {
                    if (processGraph) {
                        metadata = !parser.getAttributeValue(null, SerializationConstants.namedGraphUri)
                                .equals(graphUri);
                    }
                } else if (SerializationConstants.subject.equals(parser.getLocalName())) {
                    if (processGraph) {
                        nodeType = parser.getAttributeValue(null, SerializationConstants.subjectType);
                    }
                } else if (SerializationConstants.predicate.equals(parser.getLocalName())) {
                } else if (SerializationConstants.object.equals(parser.getLocalName())) {
                    if (processGraph) {
                        nodeType = parser.getAttributeValue(null, SerializationConstants.objectType);
                        language = parser.getAttributeValue(null, SerializationConstants.language);
                        datatype = parser.getAttributeValue(null, SerializationConstants.dataType);
                    }
                } else if (SerializationConstants.namedGraphUri.equals(parser.getLocalName())) {
                }
                break;
            case XMLStreamConstants.END_ELEMENT:
                if (SerializationConstants.namedGraph.equals(parser.getLocalName())) {
                    graphUri = null;
                    namedGraphUri = null;
                    metaURI = null;
                    uuid = null;
                    revisioned = true;
                    revisions = null;
                } else if (SerializationConstants.revisionInfo.equals(parser.getLocalName())) {
                } else if (SerializationConstants.revisions.equals(parser.getLocalName())) {
                    processGraph = handler.handleNamedGraph(revisioned, namedGraphUri, metaURI, uuid,
                            revisions);
                    revisions = null;
                } else if (SerializationConstants.statement.equals(parser.getLocalName())) {
                    if (processGraph) {
                        handler.handleStatement(metadata, revisioned,
                                Constants.valueFactory.createStatement(currentSubject, currentPredicate,
                                        currentObject, currentNamedGraphURI),
                                start, end);
                        start = null;
                        end = null;
                    }
                } else if (SerializationConstants.subject.equals(parser.getLocalName())) {
                    if (processGraph) {
                        if (NodeType.BNODE.name().equals(nodeType)) {
                            currentSubject = Constants.valueFactory.createBNode(currentValue);
                        } else {
                            currentSubject = Constants.valueFactory.createURI(currentValue);
                        }
                        currentValue = null;
                        nodeType = null;
                    }
                } else if (SerializationConstants.predicate.equals(parser.getLocalName())) {
                    if (processGraph) {
                        currentPredicate = Constants.valueFactory.createURI(currentValue);
                        currentValue = null;
                    }
                } else if (SerializationConstants.object.equals(parser.getLocalName())) {
                    if (processGraph) {
                        if (NodeType.BNODE.name().equals(nodeType)) {
                            currentObject = Constants.valueFactory.createBNode(currentValue);
                        } else if (NodeType.URI.name().equals(nodeType)) {
                            currentObject = Constants.valueFactory.createURI(currentValue);
                        } else if (NodeType.LITERAL.name().equals(nodeType)) {
                            if (currentValue == null) {
                                currentValue = "";
                            } else if (Base64
                                    .isArrayByteBase64(currentValue.getBytes(Constants.byteEncoding))) {
                                currentValue = new String(
                                        Base64.decodeBase64(currentValue.getBytes(Constants.byteEncoding)),
                                        Constants.byteEncoding);
                            }
                            if (datatype != null) {
                                currentObject = Constants.valueFactory.createLiteral(currentValue,
                                        Constants.valueFactory.createURI(datatype));
                            } else if (language != null) {
                                currentObject = Constants.valueFactory.createLiteral(currentValue, language);
                            } else {
                                currentObject = Constants.valueFactory.createLiteral(currentValue);
                            }
                        }
                        currentValue = null;
                        nodeType = null;
                        language = null;
                        datatype = null;
                    }
                } else if (SerializationConstants.namedGraphUri.equals(parser.getLocalName())) {
                    if (processGraph) {
                        currentNamedGraphURI = Constants.valueFactory.createURI(currentValue);
                        currentValue = null;
                    }
                }
                break;
            case XMLStreamConstants.CHARACTERS:
                if (parser.hasText())
                    currentValue = parser.getText();
                break;
            case XMLStreamConstants.CDATA:
                if (parser.hasText())
                    currentValue = parser.getText();
                break;
            }
        }
        parser.close();
    } catch (XMLStreamException ex) {
        throw new AnzoException(ExceptionConstants.IO.READ_ERROR, ex, ex.getMessage());
    } catch (UnsupportedEncodingException uee) {
        throw new AnzoException(ExceptionConstants.IO.ENCODING_ERROR, uee);
    }
}

From source file:org.openanzo.services.serialization.XMLNamedGraphUpdatesReader.java

/**
 * Parse the data within the reader, passing the results to the IRepositoryHandler
 * // w  w  w .j a v a  2 s.com
 * @param reader
 *            reader containing the data
 * @param handler
 *            Handler which will handle the elements within the data
 * @throws AnzoException
 */
public void parseUpdates(Reader reader, final INamedGraphUpdateHandler handler) throws AnzoException {
    try {
        XMLStreamReader parser = XMLFactoryFinder.getXMLInputFactory().createXMLStreamReader(reader);

        for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {
            switch (event) {
            case XMLStreamConstants.START_ELEMENT:
                if (SerializationConstants.namedGraph.equals(parser.getLocalName())) {
                    String uri = parser.getAttributeValue(null, SerializationConstants.namedGraphUri);
                    String uuid = parser.getAttributeValue(null, SerializationConstants.namedGraphUUID);
                    currentNamedGraphUpdate = new NamedGraphUpdate(MemURI.create(uri));
                    if (uuid != null) {
                        currentNamedGraphUpdate.setUUID(MemURI.create(uuid));
                    }
                    String revision = parser.getAttributeValue(null, SerializationConstants.revision);
                    if (revision != null) {
                        currentNamedGraphUpdate.setRevision(Long.parseLong(revision));
                    }
                } else if (SerializationConstants.additions.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getAdditions();
                } else if (SerializationConstants.metaAdditions.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getMetaAdditions();
                } else if (SerializationConstants.removals.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getRemovals();
                } else if (SerializationConstants.metaRemovals.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getMetaRemovals();
                } else if (SerializationConstants.statement.equals(parser.getLocalName())) {
                } else if (SerializationConstants.subject.equals(parser.getLocalName())) {
                    nodeType = parser.getAttributeValue(null, SerializationConstants.subjectType);
                } else if (SerializationConstants.predicate.equals(parser.getLocalName())) {
                } else if (SerializationConstants.object.equals(parser.getLocalName())) {
                    nodeType = parser.getAttributeValue(null, SerializationConstants.objectType);
                    language = parser.getAttributeValue(null, SerializationConstants.language);
                    datatype = parser.getAttributeValue(null, SerializationConstants.dataType);
                } else if (SerializationConstants.namedGraphUri.equals(parser.getLocalName())) {
                }
                break;
            case XMLStreamConstants.END_ELEMENT:
                if (SerializationConstants.namedGraph.equals(parser.getLocalName())) {
                    handler.handleNamedGraphUpdate(currentNamedGraphUpdate);
                    currentNamedGraphUpdate = null;
                } else if (SerializationConstants.additions.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.metaAdditions.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.removals.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.metaRemovals.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.statement.equals(parser.getLocalName())) {
                    currentStatements.add(Constants.valueFactory.createStatement(currentSubject,
                            currentPredicate, currentObject, currentNamedGraphURI));
                } else if (SerializationConstants.subject.equals(parser.getLocalName())) {
                    if (NodeType.BNODE.name().equals(nodeType)) {
                        currentSubject = Constants.valueFactory.createBNode(currentValue);
                    } else {
                        currentSubject = Constants.valueFactory.createURI(currentValue);
                    }
                    currentValue = null;
                    nodeType = null;
                } else if (SerializationConstants.predicate.equals(parser.getLocalName())) {
                    currentPredicate = Constants.valueFactory.createURI(currentValue);
                    currentValue = null;
                } else if (SerializationConstants.object.equals(parser.getLocalName())) {
                    if (NodeType.BNODE.name().equals(nodeType)) {
                        currentObject = Constants.valueFactory.createBNode(currentValue);
                    } else if (NodeType.URI.name().equals(nodeType)) {
                        currentObject = Constants.valueFactory.createURI(currentValue);
                    } else if (NodeType.LITERAL.name().equals(nodeType)) {
                        if (Base64.isArrayByteBase64(currentValue.getBytes(Constants.byteEncoding))) {
                            currentValue = new String(
                                    Base64.decodeBase64(currentValue.getBytes(Constants.byteEncoding)),
                                    Constants.byteEncoding);
                        }
                        if (datatype != null) {
                            currentObject = Constants.valueFactory.createLiteral(currentValue,
                                    Constants.valueFactory.createURI(datatype));
                        } else if (language != null) {
                            currentObject = Constants.valueFactory.createLiteral(currentValue, language);
                        } else {
                            currentObject = Constants.valueFactory.createLiteral(currentValue);
                        }
                    }
                    currentValue = null;
                    nodeType = null;
                    language = null;
                    datatype = null;
                } else if (SerializationConstants.namedGraphUri.equals(parser.getLocalName())) {
                    currentNamedGraphURI = Constants.valueFactory.createURI(currentValue);
                    currentValue = null;
                }
                break;
            case XMLStreamConstants.CHARACTERS:
                currentValue = parser.getText();
                break;
            case XMLStreamConstants.CDATA:
                currentValue = parser.getText();
                break;
            }
        }
        parser.close();
    } catch (XMLStreamException ex) {
        throw new AnzoException(ExceptionConstants.IO.READ_ERROR, ex, ex.getMessage());
    } catch (UnsupportedEncodingException uee) {
        throw new AnzoException(ExceptionConstants.IO.ENCODING_ERROR, uee);
    }
}

From source file:org.openanzo.services.serialization.XMLUpdatesReader.java

/**
 * Parse the data within the reader, passing the results to the IRepositoryHandler
 * //from  w  ww.j  a  va2s .  c om
 * @param reader
 *            reader containing the data
 * @param handler
 *            Handler which will handle the elements within the data
 * @throws AnzoException
 */
private void parseUpdateTransactions(Reader reader, final IUpdatesHandler handler) throws AnzoException {
    try {
        XMLStreamReader parser = XMLFactoryFinder.getXMLInputFactory().createXMLStreamReader(reader);

        for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {
            switch (event) {
            case XMLStreamConstants.START_ELEMENT:
                if (SerializationConstants.transaction.equals(parser.getLocalName())) {
                    currentTransaction = parseTransaction(parser);
                } else if (SerializationConstants.transactionContext.equals(parser.getLocalName())) {
                    currentStatements = currentTransaction.getTransactionContext();
                } else if (SerializationConstants.preconditions.equals(parser.getLocalName())) {
                    currentStatements = new ArrayList<Statement>();
                } else if (SerializationConstants.namedGraphUpdates.equals(parser.getLocalName())) {
                    currentValue = null;
                } else if (SerializationConstants.namedGraph.equals(parser.getLocalName())) {
                    String uri = parser.getAttributeValue(null, SerializationConstants.namedGraphUri);
                    String uuid = parser.getAttributeValue(null, SerializationConstants.namedGraphUUID);
                    currentNamedGraphUpdate = new NamedGraphUpdate(MemURI.create(uri));
                    if (uuid != null) {
                        currentNamedGraphUpdate.setUUID(MemURI.create(uuid));
                    }
                    String revision = parser.getAttributeValue(null, SerializationConstants.revision);
                    if (revision != null) {
                        currentNamedGraphUpdate.setRevision(Long.parseLong(revision));
                    }
                } else if (SerializationConstants.additions.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getAdditions();
                } else if (SerializationConstants.metaAdditions.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getMetaAdditions();
                } else if (SerializationConstants.removals.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getRemovals();
                } else if (SerializationConstants.metaRemovals.equals(parser.getLocalName())) {
                    currentStatements = currentNamedGraphUpdate.getMetaRemovals();
                } else if (SerializationConstants.statement.equals(parser.getLocalName())) {
                } else if (SerializationConstants.subject.equals(parser.getLocalName())) {
                    nodeType = parser.getAttributeValue(null, SerializationConstants.subjectType);
                } else if (SerializationConstants.predicate.equals(parser.getLocalName())) {
                } else if (SerializationConstants.object.equals(parser.getLocalName())) {
                    nodeType = parser.getAttributeValue(null, SerializationConstants.objectType);
                    language = parser.getAttributeValue(null, SerializationConstants.language);
                    datatype = parser.getAttributeValue(null, SerializationConstants.dataType);
                } else if (SerializationConstants.namedGraphUri.equals(parser.getLocalName())) {
                } else if (SerializationConstants.errorResult.equals(parser.getLocalName())) {
                    String errorCodeStr = parser.getAttributeValue(null, SerializationConstants.errorCode);
                    errorCode = Long.parseLong(errorCodeStr);
                    errorArgs = new ArrayList<String>();
                } else if (SerializationConstants.errorMessageArg.equals(parser.getLocalName())) {

                }
                break;
            case XMLStreamConstants.END_ELEMENT:
                if (SerializationConstants.transaction.equals(parser.getLocalName())) {
                    handler.handleTransaction(currentTransaction);
                    currentTransaction = null;
                } else if (SerializationConstants.transactionContext.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.preconditions.equals(parser.getLocalName())) {
                    currentTransaction.getPreconditions()
                            .addAll(CommonSerializationUtils.parsePreconditionStatements(currentStatements));
                } else if (SerializationConstants.namedGraphUpdates.equals(parser.getLocalName())) {
                    if (currentValue != null)
                        currentTransaction.getUpdatedNamedGraphRevisions()
                                .putAll(CommonSerializationUtils.readNamedGraphRevisions(currentValue));
                } else if (SerializationConstants.namedGraph.equals(parser.getLocalName())) {
                    currentTransaction.addNamedGraphUpdate(currentNamedGraphUpdate);
                } else if (SerializationConstants.additions.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.metaAdditions.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.removals.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.metaRemovals.equals(parser.getLocalName())) {
                    currentStatements = null;
                } else if (SerializationConstants.statement.equals(parser.getLocalName())) {
                    currentStatements.add(Constants.valueFactory.createStatement(currentSubject,
                            currentPredicate, currentObject, currentNamedGraphURI));
                } else if (SerializationConstants.subject.equals(parser.getLocalName())) {
                    if (NodeType.BNODE.name().equals(nodeType)) {
                        currentSubject = Constants.valueFactory.createBNode(currentValue);
                    } else {
                        currentSubject = Constants.valueFactory.createURI(currentValue);
                    }
                    currentValue = null;
                    nodeType = null;
                } else if (SerializationConstants.predicate.equals(parser.getLocalName())) {
                    currentPredicate = Constants.valueFactory.createURI(currentValue);
                    currentValue = null;
                } else if (SerializationConstants.object.equals(parser.getLocalName())) {
                    if (NodeType.BNODE.name().equals(nodeType)) {
                        currentObject = Constants.valueFactory.createBNode(currentValue);
                    } else if (NodeType.URI.name().equals(nodeType)) {
                        currentObject = Constants.valueFactory.createURI(currentValue);
                    } else if (NodeType.LITERAL.name().equals(nodeType)) {
                        if (currentValue == null) {
                            currentValue = "";
                        } else if (Base64.isArrayByteBase64(currentValue.getBytes(Constants.byteEncoding))) {
                            currentValue = new String(
                                    Base64.decodeBase64(currentValue.getBytes(Constants.byteEncoding)),
                                    Constants.byteEncoding);
                        }
                        if (datatype != null) {
                            currentObject = Constants.valueFactory.createLiteral(currentValue,
                                    Constants.valueFactory.createURI(datatype));
                        } else if (language != null) {
                            currentObject = Constants.valueFactory.createLiteral(currentValue, language);
                        } else {
                            currentObject = Constants.valueFactory.createLiteral(currentValue);
                        }
                    }
                    currentValue = null;
                    nodeType = null;
                    language = null;
                    datatype = null;
                } else if (SerializationConstants.namedGraphUri.equals(parser.getLocalName())) {
                    currentNamedGraphURI = Constants.valueFactory.createURI(currentValue);
                    currentValue = null;
                } else if (SerializationConstants.errorResult.equals(parser.getLocalName())) {
                    currentTransaction.getErrors()
                            .add(new AnzoException(errorCode, errorArgs.toArray(new String[0])));
                    errorCode = 0;
                    errorArgs = null;
                } else if (SerializationConstants.errorMessageArg.equals(parser.getLocalName())) {
                    errorArgs.add(currentValue);
                    currentValue = null;
                }
                break;
            case XMLStreamConstants.CHARACTERS:
                if (parser.hasText())
                    currentValue = parser.getText();
                break;
            case XMLStreamConstants.CDATA:
                if (parser.hasText())
                    currentValue = parser.getText();
                break;
            }
        }
        parser.close();
    } catch (XMLStreamException ex) {
        throw new AnzoException(ExceptionConstants.IO.READ_ERROR, ex, ex.getMessage());
    } catch (UnsupportedEncodingException uee) {
        throw new AnzoException(ExceptionConstants.IO.ENCODING_ERROR, uee);
    }
}

From source file:org.pentaho.di.trans.steps.webservices.WebService.java

private void compatibleProcessRows(InputStream anXml, Object[] rowData, RowMetaInterface rowMeta,
        boolean ignoreNamespacePrefix, String encoding) throws KettleException {

    // First we should get the complete string
    // The problem is that the string can contain XML or any other format such as HTML saying the service is no longer
    // available.
    // We're talking about a WEB service here.
    // As such, to keep the original parsing scheme, we first read the content.
    // Then we create an input stream from the content again.
    // It's elaborate, but that way we can report on the failure more correctly.
    ///*from  w w w.  j  av a2  s.  c  o  m*/
    String response = readStringFromInputStream(anXml, encoding);

    // Create a new reader to feed into the XML Input Factory below...
    //
    StringReader stringReader = new StringReader(response.toString());

    // TODO Very empirical : see if we can do something better here
    try {
        XMLInputFactory vFactory = XMLInputFactory.newInstance();
        XMLStreamReader vReader = vFactory.createXMLStreamReader(stringReader);

        Object[] outputRowData = RowDataUtil.allocateRowData(data.outputRowMeta.size());
        int outputIndex = 0;

        boolean processing = false;
        boolean oneValueRowProcessing = false;
        for (int event = vReader.next(); vReader.hasNext(); event = vReader.next()) {
            switch (event) {
            case XMLStreamConstants.START_ELEMENT:

                // Start new code
                // START_ELEMENT= 1
                //
                if (log.isRowLevel()) {
                    logRowlevel("START_ELEMENT / " + vReader.getAttributeCount() + " / "
                            + vReader.getNamespaceCount());
                }

                // If we start the xml element named like the return type,
                // we start a new row
                //
                if (log.isRowLevel()) {
                    logRowlevel("vReader.getLocalName = " + vReader.getLocalName());
                }
                if (Const.isEmpty(meta.getOutFieldArgumentName())) {
                    // getOutFieldArgumentName() == null
                    if (oneValueRowProcessing) {
                        WebServiceField field = meta.getFieldOutFromWsName(vReader.getLocalName(),
                                ignoreNamespacePrefix);
                        if (field != null) {
                            outputRowData[outputIndex++] = getValue(vReader.getElementText(), field);
                            putRow(data.outputRowMeta, outputRowData);
                            oneValueRowProcessing = false;
                        } else {
                            if (meta.getOutFieldContainerName().equals(vReader.getLocalName())) {
                                // meta.getOutFieldContainerName() = vReader.getLocalName()
                                if (log.isRowLevel()) {
                                    logRowlevel("OutFieldContainerName = " + meta.getOutFieldContainerName());
                                }
                                oneValueRowProcessing = true;
                            }
                        }
                    }
                } else {
                    // getOutFieldArgumentName() != null
                    if (log.isRowLevel()) {
                        logRowlevel("OutFieldArgumentName = " + meta.getOutFieldArgumentName());
                    }
                    if (meta.getOutFieldArgumentName().equals(vReader.getLocalName())) {
                        if (log.isRowLevel()) {
                            logRowlevel("vReader.getLocalName = " + vReader.getLocalName());
                        }
                        if (log.isRowLevel()) {
                            logRowlevel("OutFieldArgumentName = ");
                        }
                        if (processing) {
                            WebServiceField field = meta.getFieldOutFromWsName(vReader.getLocalName(),
                                    ignoreNamespacePrefix);
                            if (field != null) {
                                int index = data.outputRowMeta.indexOfValue(field.getName());
                                if (index >= 0) {
                                    outputRowData[index] = getValue(vReader.getElementText(), field);
                                }
                            }
                            processing = false;
                        } else {
                            WebServiceField field = meta.getFieldOutFromWsName(vReader.getLocalName(),
                                    ignoreNamespacePrefix);
                            if (meta.getFieldsOut().size() == 1 && field != null) {
                                // This can be either a simple return element, or a complex type...
                                //
                                try {
                                    if (meta.isPassingInputData()) {
                                        for (int i = 0; i < rowMeta.getValueMetaList().size(); i++) {
                                            ValueMetaInterface valueMeta = getInputRowMeta().getValueMeta(i);
                                            outputRowData[outputIndex++] = valueMeta.cloneValueData(rowData[i]);

                                        }
                                    }

                                    outputRowData[outputIndex++] = getValue(vReader.getElementText(), field);
                                    putRow(data.outputRowMeta, outputRowData);
                                } catch (WstxParsingException e) {
                                    throw new KettleStepException("Unable to get value for field ["
                                            + field.getName()
                                            + "].  Verify that this is not a complex data type by looking at the response XML.",
                                            e);
                                }
                            } else {
                                for (WebServiceField curField : meta.getFieldsOut()) {
                                    if (!Const.isEmpty(curField.getName())) {
                                        outputRowData[outputIndex++] = getValue(vReader.getElementText(),
                                                curField);
                                    }
                                }
                                processing = true;
                            }
                        }

                    } else {
                        if (log.isRowLevel()) {
                            logRowlevel("vReader.getLocalName = " + vReader.getLocalName());
                        }
                        if (log.isRowLevel()) {
                            logRowlevel("OutFieldArgumentName = " + meta.getOutFieldArgumentName());
                        }
                    }
                }
                break;

            case XMLStreamConstants.END_ELEMENT:
                // END_ELEMENT= 2
                if (log.isRowLevel()) {
                    logRowlevel("END_ELEMENT");
                }
                // If we end the xml element named as the return type, we
                // finish a row
                if ((meta.getOutFieldArgumentName() == null
                        && meta.getOperationName().equals(vReader.getLocalName()))) {
                    oneValueRowProcessing = false;
                } else if (meta.getOutFieldArgumentName() != null
                        && meta.getOutFieldArgumentName().equals(vReader.getLocalName())) {
                    putRow(data.outputRowMeta, outputRowData);
                    processing = false;
                }
                break;
            case XMLStreamConstants.PROCESSING_INSTRUCTION:
                // PROCESSING_INSTRUCTION= 3
                if (log.isRowLevel()) {
                    logRowlevel("PROCESSING_INSTRUCTION");
                }
                break;
            case XMLStreamConstants.CHARACTERS:
                // CHARACTERS= 4
                if (log.isRowLevel()) {
                    logRowlevel("CHARACTERS");
                }
                break;
            case XMLStreamConstants.COMMENT:
                // COMMENT= 5
                if (log.isRowLevel()) {
                    logRowlevel("COMMENT");
                }
                break;
            case XMLStreamConstants.SPACE:
                // PROCESSING_INSTRUCTION= 6
                if (log.isRowLevel()) {
                    logRowlevel("PROCESSING_INSTRUCTION");
                }
                break;
            case XMLStreamConstants.START_DOCUMENT:
                // START_DOCUMENT= 7
                if (log.isRowLevel()) {
                    logRowlevel("START_DOCUMENT");
                }
                if (log.isRowLevel()) {
                    logRowlevel(vReader.getText());
                }
                break;
            case XMLStreamConstants.END_DOCUMENT:
                // END_DOCUMENT= 8
                if (log.isRowLevel()) {
                    logRowlevel("END_DOCUMENT");
                }
                break;
            case XMLStreamConstants.ENTITY_REFERENCE:
                // ENTITY_REFERENCE= 9
                if (log.isRowLevel()) {
                    logRowlevel("ENTITY_REFERENCE");
                }
                break;
            case XMLStreamConstants.ATTRIBUTE:
                // ATTRIBUTE= 10
                if (log.isRowLevel()) {
                    logRowlevel("ATTRIBUTE");
                }
                break;
            case XMLStreamConstants.DTD:
                // DTD= 11
                if (log.isRowLevel()) {
                    logRowlevel("DTD");
                }
                break;
            case XMLStreamConstants.CDATA:
                // CDATA= 12
                if (log.isRowLevel()) {
                    logRowlevel("CDATA");
                }
                break;
            case XMLStreamConstants.NAMESPACE:
                // NAMESPACE= 13
                if (log.isRowLevel()) {
                    logRowlevel("NAMESPACE");
                }
                break;
            case XMLStreamConstants.NOTATION_DECLARATION:
                // NOTATION_DECLARATION= 14
                if (log.isRowLevel()) {
                    logRowlevel("NOTATION_DECLARATION");
                }
                break;
            case XMLStreamConstants.ENTITY_DECLARATION:
                // ENTITY_DECLARATION= 15
                if (log.isRowLevel()) {
                    logRowlevel("ENTITY_DECLARATION");
                }
                break;
            default:
                break;
            }
        }
    } catch (Exception e) {
        throw new KettleStepException(
                BaseMessages.getString(PKG, "WebServices.ERROR0010.OutputParsingError", response.toString()),
                e);
    }
}

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

private Object[] processEvent() throws KettleException {

    Object[] outputRowData = RowDataUtil.allocateRowData(data.outputRowMeta.size());
    XMLEvent e = null;/*  w w  w .j a v  a2s.  co m*/
    try {
        e = data.xmlEventReader.nextEvent();
    } catch (XMLStreamException ex) {
        throw new KettleException(ex);
    }

    int eventType = e.getEventType();
    if (data.pos_xml_data_type_numeric != -1) {
        outputRowData[data.pos_xml_data_type_numeric] = new Long(eventType);
    }
    if (data.pos_xml_data_type_description != -1) {
        if (eventType == 0 || eventType > eventDescription.length) {
            // unknown eventType
            outputRowData[data.pos_xml_data_type_description] = eventDescription[0] + "(" + eventType + ")";
        } else {
            outputRowData[data.pos_xml_data_type_description] = eventDescription[eventType];
        }
    }
    if (data.pos_xml_location_line != -1) {
        outputRowData[data.pos_xml_location_line] = new Long(e.getLocation().getLineNumber());
    }
    if (data.pos_xml_location_column != -1) {
        outputRowData[data.pos_xml_location_column] = new Long(e.getLocation().getColumnNumber());
    }

    switch (eventType) {

    case XMLStreamConstants.START_ELEMENT:
        data.elementLevel++;
        if (data.elementLevel > PARENT_ID_ALLOCATE_SIZE - 1) {
            throw new KettleException(BaseMessages.getString(PKG, "XMLInputStream.Log.TooManyNestedElements",
                    PARENT_ID_ALLOCATE_SIZE));
        }
        if (data.elementParentID[data.elementLevel] == null) {
            data.elementParentID[data.elementLevel] = data.elementID;
        }
        data.elementID++;
        data.elementLevelID[data.elementLevel] = data.elementID;

        String xml_data_name;
        if (meta.isEnableNamespaces()) {
            String prefix = e.asStartElement().getName().getPrefix();
            if (Utils.isEmpty(prefix)) {
                xml_data_name = e.asStartElement().getName().getLocalPart();
            } else { // add namespace prefix:
                xml_data_name = prefix + ":" + e.asStartElement().getName().getLocalPart();
            }
        } else {
            xml_data_name = e.asStartElement().getName().getLocalPart();
        }
        if (data.pos_xml_data_name >= 0) {
            outputRowData[data.pos_xml_data_name] = xml_data_name;
        }
        // store the name
        data.elementName[data.elementLevel] = xml_data_name;
        // store simple path
        data.elementPath[data.elementLevel] = data.elementPath[data.elementLevel - 1] + "/" + xml_data_name;

        // write Namespaces out
        if (meta.isEnableNamespaces()) {
            outputRowData = parseNamespaces(outputRowData, e);
        }

        // write Attributes out
        outputRowData = parseAttributes(outputRowData, e);

        break;

    case XMLStreamConstants.END_ELEMENT:
        parseEndElement(outputRowData, e.asEndElement());
        putRowOut(outputRowData);
        data.elementParentID[data.elementLevel + 1] = null;
        data.elementLevel--;
        outputRowData = null; // continue
        break;

    case XMLStreamConstants.SPACE:
        outputRowData = null; // ignore & continue
        break;

    case XMLStreamConstants.CHARACTERS:
    case XMLStreamConstants.CDATA:
        if (data.pos_xml_data_name >= 0) {
            outputRowData[data.pos_xml_data_name] = data.elementName[data.elementLevel];
        }
        String xml_data_value = e.asCharacters().getData();
        if (data.pos_xml_data_value >= 0) {
            if (meta.isEnableTrim()) {
                // optional trim is also eliminating white spaces, tab, cr, lf
                xml_data_value = Const.trim(xml_data_value);
            }
            outputRowData[data.pos_xml_data_value] = xml_data_value;
        }

        if (data.pos_xml_data_value < 0 || Utils.isEmpty((String) outputRowData[data.pos_xml_data_value])) {
            outputRowData = null; // ignore & continue
        }
        break;

    case XMLStreamConstants.PROCESSING_INSTRUCTION:
        outputRowData = null; // ignore & continue
        // TODO test if possible
        break;

    case XMLStreamConstants.COMMENT:
        outputRowData = null; // ignore & continue
        // TODO test if possible
        break;

    case XMLStreamConstants.ENTITY_REFERENCE:
        // should be resolved by default
        outputRowData = null; // ignore & continue
        break;

    case XMLStreamConstants.START_DOCUMENT:
        // just get this information out
        break;

    case XMLStreamConstants.END_DOCUMENT:
        // just get this information out
        break;

    default:
        logBasic("Event:" + eventType);
        outputRowData = null; // ignore & continue
    }

    return outputRowData;
}

From source file:org.reusables.dbunit.autocomplete.AutoCompletionRules.java

private void parseTable(final XMLStreamReader parser) throws XMLStreamException {
    final String name = getName(parser);
    final Map<String, AutoCompletionColumn> columns = addTable(name);
    AutoCompletionColumn currentColumn = null;

    for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser.next()) {
        if (event == XMLStreamConstants.START_ELEMENT) {
            currentColumn = parseColumn(parser);
            columns.put(currentColumn.getName().toLowerCase(), currentColumn);
        } else if (event == XMLStreamConstants.CHARACTERS || event == XMLStreamConstants.CDATA) {
            parseColumnValue(parser, currentColumn);
        } else if (event == XMLStreamConstants.END_ELEMENT) {
            currentColumn = null;//from   w  w  w.  j a v a 2  s  .co  m
            if (ELEM_TABLE.equals(parser.getLocalName())) {
                return;
            }
        }
    }
}