Example usage for javax.xml.stream XMLStreamReader hasNext

List of usage examples for javax.xml.stream XMLStreamReader hasNext

  1. HOME
  2. Java
  3. javax
  4. javax.xml.stream.*
  5. XMLStreamReader
  6. hasNext

Introduction

In this page you can find the example usage for javax.xml.stream XMLStreamReader hasNext.

Prototype

public boolean hasNext() throws XMLStreamException;

Source Link

Document

Returns true if there are more parsing events and false if there are no more events.

Usage

From source file:net.xy.jcms.controller.configurations.parser.UsecaseParser.java

/**
 * method for parsing single usecase xml files. one per file.
 * //from  w  ww.j a v a  2s.c  om
 * @param in
 * @param loader
 * @return parsed usecase
 * @throws XMLStreamException
 * @throws ClassNotFoundException
 */
public static Usecase parseSingle(final InputStream in, final ClassLoader loader)
        throws XMLStreamException, ClassNotFoundException {
    final XMLInputFactory factory = XMLInputFactory.newInstance();
    factory.setProperty("javax.xml.stream.isCoalescing", true);
    // not supported by the reference implementation
    // factory.setProperty(XMLInputFactory.IS_VALIDATING, Boolean.TRUE);
    final XMLStreamReader parser = factory.createXMLStreamReader(in);
    while (parser.hasNext()) {
        final int event = parser.next();
        if (event == XMLStreamConstants.START_ELEMENT && parser.getName().getLocalPart().equals("usecase")) {
            return parseUsecase(parser, loader);
        }
    }
    throw new IllegalArgumentException("No usecases section found. [" + parser.getLocation() + "]");
}

From source file:nl.knaw.huygens.tei.xpath.XPathUtil.java

public static Map<String, String> getNamespaceInfo(String xml) {
    Map<String, String> namespaces = Maps.newIdentityHashMap();
    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    try {/*  ww  w  .j  a v  a2 s.co m*/
        XMLStreamReader xreader = inputFactory.createXMLStreamReader(IOUtils.toInputStream(xml, "UTF-8"));
        while (xreader.hasNext()) {
            if (xreader.next() == XMLStreamConstants.START_ELEMENT) {
                QName qName = xreader.getName();
                if (qName != null) {
                    addNamespace(namespaces, qName.getPrefix(), qName.getNamespaceURI());
                    for (int i = 0; i < xreader.getAttributeCount(); i++) {
                        addNamespace(namespaces, xreader.getAttributePrefix(i),
                                xreader.getAttributeNamespace(i));
                    }
                }
            }
        }
    } catch (XMLStreamException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return namespaces;
}

From source file:org.activiti.bpmn.converter.BaseBpmnXMLConverter.java

@SuppressWarnings("unchecked")
protected ExtensionElement parseExtensionElement(XMLStreamReader xtr) throws Exception {
    ExtensionElement extensionElement = new ExtensionElement();
    extensionElement.setName(xtr.getLocalName());
    if (StringUtils.isNotEmpty(xtr.getNamespaceURI())) {
        extensionElement.setNamespace(xtr.getNamespaceURI());
    }/*from   ww  w  .jav  a 2s .c  om*/
    if (StringUtils.isNotEmpty(xtr.getPrefix())) {
        extensionElement.setNamespacePrefix(xtr.getPrefix());
    }

    BpmnXMLUtil.addCustomAttributes(xtr, extensionElement, defaultElementAttributes);

    boolean readyWithExtensionElement = false;
    while (readyWithExtensionElement == false && xtr.hasNext()) {
        xtr.next();
        if (xtr.isCharacters()) {
            if (StringUtils.isNotEmpty(xtr.getText().trim())) {
                extensionElement.setElementText(xtr.getText().trim());
            }
        } else if (xtr.isStartElement()) {
            ExtensionElement childExtensionElement = parseExtensionElement(xtr);
            extensionElement.addChildElement(childExtensionElement);
        } else if (xtr.isEndElement() && extensionElement.getName().equalsIgnoreCase(xtr.getLocalName())) {
            readyWithExtensionElement = true;
        }
    }
    return extensionElement;
}

From source file:org.activiti.bpmn.converter.BpmnXMLConverter.java

public BpmnModel convertToBpmnModel(XMLStreamReader xtr) {
    BpmnModel model = new BpmnModel();
    model.setStartEventFormTypes(startEventFormTypes);
    model.setUserTaskFormTypes(userTaskFormTypes);
    try {//from  w w w  .  ja  v  a 2s  .c  om
        Process activeProcess = null;
        List<SubProcess> activeSubProcessList = new ArrayList<SubProcess>();
        while (xtr.hasNext()) {
            try {
                xtr.next();
            } catch (Exception e) {
                LOGGER.debug("Error reading XML document", e);
                throw new XMLException("Error reading XML", e);
            }

            if (xtr.isEndElement() && ELEMENT_SUBPROCESS.equals(xtr.getLocalName())) {
                activeSubProcessList.remove(activeSubProcessList.size() - 1);
            }

            if (xtr.isEndElement() && ELEMENT_TRANSACTION.equals(xtr.getLocalName())) {
                activeSubProcessList.remove(activeSubProcessList.size() - 1);
            }

            if (xtr.isStartElement() == false)
                continue;

            if (ELEMENT_DEFINITIONS.equals(xtr.getLocalName())) {
                definitionsParser.parse(xtr, model);

            } else if (ELEMENT_SIGNAL.equals(xtr.getLocalName())) {
                signalParser.parse(xtr, model);

            } else if (ELEMENT_MESSAGE.equals(xtr.getLocalName())) {
                messageParser.parse(xtr, model);

            } else if (ELEMENT_ERROR.equals(xtr.getLocalName())) {

                if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_ID))) {
                    model.addError(xtr.getAttributeValue(null, ATTRIBUTE_ID),
                            xtr.getAttributeValue(null, ATTRIBUTE_ERROR_CODE));
                }

            } else if (ELEMENT_IMPORT.equals(xtr.getLocalName())) {
                importParser.parse(xtr, model);

            } else if (ELEMENT_ITEM_DEFINITION.equals(xtr.getLocalName())) {
                itemDefinitionParser.parse(xtr, model);

            } else if (ELEMENT_INTERFACE.equals(xtr.getLocalName())) {
                interfaceParser.parse(xtr, model);

            } else if (ELEMENT_IOSPECIFICATION.equals(xtr.getLocalName())) {
                new IOSpecificationParser().parseChildElement(xtr, activeProcess, model);

            } else if (ELEMENT_PARTICIPANT.equals(xtr.getLocalName())) {

                if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_ID))) {
                    Pool pool = new Pool();
                    pool.setId(xtr.getAttributeValue(null, ATTRIBUTE_ID));
                    pool.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
                    pool.setProcessRef(xtr.getAttributeValue(null, ATTRIBUTE_PROCESS_REF));
                    BpmnXMLUtil.parseChildElements(ELEMENT_PARTICIPANT, pool, xtr, model);
                    model.getPools().add(pool);
                }

            } else if (ELEMENT_PROCESS.equals(xtr.getLocalName())) {

                Process process = processParser.parse(xtr, model);
                if (process != null) {
                    activeProcess = process;
                }

            } else if (ELEMENT_POTENTIAL_STARTER.equals(xtr.getLocalName())) {
                potentialStarterParser.parse(xtr, activeProcess);

            } else if (ELEMENT_LANE.equals(xtr.getLocalName())) {
                laneParser.parse(xtr, activeProcess, model);

            } else if (ELEMENT_DOCUMENTATION.equals(xtr.getLocalName())) {

                BaseElement parentElement = null;
                if (activeSubProcessList.size() > 0) {
                    parentElement = activeSubProcessList.get(activeSubProcessList.size() - 1);
                } else if (activeProcess != null) {
                    parentElement = activeProcess;
                }
                new DocumentationParser().parseChildElement(xtr, parentElement, model);

            } else if (activeProcess == null && ELEMENT_TEXT_ANNOTATION.equals(xtr.getLocalName())) {
                String elementId = xtr.getAttributeValue(null, ATTRIBUTE_ID);
                TextAnnotation textAnnotation = (TextAnnotation) new TextAnnotationXMLConverter()
                        .convertXMLToElement(xtr, model);
                textAnnotation.setId(elementId);
                model.getGlobalArtifacts().add(textAnnotation);

            } else if (activeProcess == null && ELEMENT_ASSOCIATION.equals(xtr.getLocalName())) {
                String elementId = xtr.getAttributeValue(null, ATTRIBUTE_ID);
                Association association = (Association) new AssociationXMLConverter().convertXMLToElement(xtr,
                        model);
                association.setId(elementId);
                model.getGlobalArtifacts().add(association);

            } else if (ELEMENT_EXTENSIONS.equals(xtr.getLocalName())) {
                new ExtensionElementsParser().parse(xtr, activeSubProcessList, activeProcess, model);

            } else if (ELEMENT_SUBPROCESS.equals(xtr.getLocalName())) {
                subProcessParser.parse(xtr, activeSubProcessList, activeProcess);

            } else if (ELEMENT_TRANSACTION.equals(xtr.getLocalName())) {
                subProcessParser.parse(xtr, activeSubProcessList, activeProcess);

            } else if (ELEMENT_DI_SHAPE.equals(xtr.getLocalName())) {
                bpmnShapeParser.parse(xtr, model);

            } else if (ELEMENT_DI_EDGE.equals(xtr.getLocalName())) {
                bpmnEdgeParser.parse(xtr, model);

            } else {

                if (activeSubProcessList.size() > 0
                        && ELEMENT_MULTIINSTANCE.equalsIgnoreCase(xtr.getLocalName())) {

                    new MultiInstanceParser().parseChildElement(xtr,
                            activeSubProcessList.get(activeSubProcessList.size() - 1), model);

                } else if (convertersToBpmnMap.containsKey(xtr.getLocalName())) {
                    if (activeProcess != null) {
                        BaseBpmnXMLConverter converter = convertersToBpmnMap.get(xtr.getLocalName());
                        converter.convertToBpmnModel(xtr, model, activeProcess, activeSubProcessList);
                    }
                }
            }
        }

        for (Process process : model.getProcesses()) {
            for (Pool pool : model.getPools()) {
                if (process.getId().equals(pool.getProcessRef())) {
                    pool.setExecutable(process.isExecutable());
                }
            }
            processFlowElements(process.getFlowElements(), process);
        }

    } catch (XMLException e) {
        throw e;

    } catch (Exception e) {
        LOGGER.error("Error processing BPMN document", e);
        throw new XMLException("Error processing BPMN document", e);
    }
    return model;
}

From source file:org.activiti.bpmn.converter.child.DataAssociationParser.java

public static void parseDataAssociation(DataAssociation dataAssociation, String elementName,
        XMLStreamReader xtr) {
    boolean readyWithDataAssociation = false;
    Assignment assignment = null;/*from  w w  w  .ja  v  a2s.c om*/
    try {
        while (readyWithDataAssociation == false && xtr.hasNext()) {
            xtr.next();
            if (xtr.isStartElement() && ELEMENT_SOURCE_REF.equals(xtr.getLocalName())) {
                String sourceRef = xtr.getElementText();
                if (StringUtils.isNotEmpty(sourceRef)) {
                    dataAssociation.setSourceRef(sourceRef.trim());
                }

            } else if (xtr.isStartElement() && ELEMENT_TARGET_REF.equals(xtr.getLocalName())) {
                String targetRef = xtr.getElementText();
                if (StringUtils.isNotEmpty(targetRef)) {
                    dataAssociation.setTargetRef(targetRef.trim());
                }

            } else if (xtr.isStartElement() && ELEMENT_TRANSFORMATION.equals(xtr.getLocalName())) {
                String transformation = xtr.getElementText();
                if (StringUtils.isNotEmpty(transformation)) {
                    dataAssociation.setTransformation(transformation.trim());
                }

            } else if (xtr.isStartElement() && ELEMENT_ASSIGNMENT.equals(xtr.getLocalName())) {
                assignment = new Assignment();
                BpmnXMLUtil.addXMLLocation(assignment, xtr);

            } else if (xtr.isStartElement() && ELEMENT_FROM.equals(xtr.getLocalName())) {
                String from = xtr.getElementText();
                if (assignment != null && StringUtils.isNotEmpty(from)) {
                    assignment.setFrom(from.trim());
                }

            } else if (xtr.isStartElement() && ELEMENT_TO.equals(xtr.getLocalName())) {
                String to = xtr.getElementText();
                if (assignment != null && StringUtils.isNotEmpty(to)) {
                    assignment.setTo(to.trim());
                }

            } else if (xtr.isEndElement() && ELEMENT_ASSIGNMENT.equals(xtr.getLocalName())) {
                if (StringUtils.isNotEmpty(assignment.getFrom())
                        && StringUtils.isNotEmpty(assignment.getTo())) {
                    dataAssociation.getAssignments().add(assignment);
                }

            } else if (xtr.isEndElement() && elementName.equals(xtr.getLocalName())) {
                readyWithDataAssociation = true;
            }
        }
    } catch (Exception e) {
        LOGGER.warn("Error parsing data association child elements", e);
    }
}

From source file:org.activiti.bpmn.converter.child.FieldExtensionParser.java

public void parseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
        throws Exception {

    if (parentElement instanceof ActivitiListener == false && parentElement instanceof ServiceTask == false
            && parentElement instanceof SendTask == false)
        return;//from ww w .  jav  a 2 s.c o m

    FieldExtension extension = new FieldExtension();
    BpmnXMLUtil.addXMLLocation(extension, xtr);
    extension.setFieldName(xtr.getAttributeValue(null, ATTRIBUTE_FIELD_NAME));

    if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_FIELD_STRING))) {
        extension.setStringValue(xtr.getAttributeValue(null, ATTRIBUTE_FIELD_STRING));

    } else if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_FIELD_EXPRESSION))) {
        extension.setExpression(xtr.getAttributeValue(null, ATTRIBUTE_FIELD_EXPRESSION));

    } else {
        boolean readyWithFieldExtension = false;
        try {
            while (readyWithFieldExtension == false && xtr.hasNext()) {
                xtr.next();
                if (xtr.isStartElement() && ELEMENT_FIELD_STRING.equalsIgnoreCase(xtr.getLocalName())) {
                    extension.setStringValue(xtr.getElementText().trim());

                } else if (xtr.isStartElement()
                        && ATTRIBUTE_FIELD_EXPRESSION.equalsIgnoreCase(xtr.getLocalName())) {
                    extension.setExpression(xtr.getElementText().trim());

                } else if (xtr.isEndElement() && getElementName().equalsIgnoreCase(xtr.getLocalName())) {
                    readyWithFieldExtension = true;
                }
            }
        } catch (Exception e) {
            LOGGER.warn("Error parsing field extension child elements", e);
        }
    }

    if (parentElement instanceof ActivitiListener) {
        ((ActivitiListener) parentElement).getFieldExtensions().add(extension);
    } else if (parentElement instanceof ServiceTask) {
        ((ServiceTask) parentElement).getFieldExtensions().add(extension);
    } else {
        ((SendTask) parentElement).getFieldExtensions().add(extension);
    }
}

From source file:org.activiti.bpmn.converter.child.FormPropertyParser.java

public void parseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
        throws Exception {

    if (parentElement instanceof UserTask == false && parentElement instanceof StartEvent == false)
        return;//from w  ww.j ava2s  .c o  m

    FormProperty property = new FormProperty();
    BpmnXMLUtil.addXMLLocation(property, xtr);
    property.setId(xtr.getAttributeValue(null, ATTRIBUTE_FORM_ID));
    property.setName(xtr.getAttributeValue(null, ATTRIBUTE_FORM_NAME));
    property.setType(xtr.getAttributeValue(null, ATTRIBUTE_FORM_TYPE));
    property.setVariable(xtr.getAttributeValue(null, ATTRIBUTE_FORM_VARIABLE));
    property.setExpression(xtr.getAttributeValue(null, ATTRIBUTE_FORM_EXPRESSION));
    property.setDefaultExpression(xtr.getAttributeValue(null, ATTRIBUTE_FORM_DEFAULT));
    property.setDatePattern(xtr.getAttributeValue(null, ATTRIBUTE_FORM_DATEPATTERN));
    if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_FORM_REQUIRED))) {
        property.setRequired(Boolean.valueOf(xtr.getAttributeValue(null, ATTRIBUTE_FORM_REQUIRED)));
    }
    if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_FORM_READABLE))) {
        property.setReadable(Boolean.valueOf(xtr.getAttributeValue(null, ATTRIBUTE_FORM_READABLE)));
    }
    if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_FORM_WRITABLE))) {
        property.setWriteable(Boolean.valueOf(xtr.getAttributeValue(null, ATTRIBUTE_FORM_WRITABLE)));
    }

    boolean readyWithFormProperty = false;
    try {
        while (readyWithFormProperty == false && xtr.hasNext()) {
            xtr.next();
            if (xtr.isStartElement() && ELEMENT_VALUE.equalsIgnoreCase(xtr.getLocalName())) {
                FormValue value = new FormValue();
                BpmnXMLUtil.addXMLLocation(value, xtr);
                value.setId(xtr.getAttributeValue(null, ATTRIBUTE_ID));
                value.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
                property.getFormValues().add(value);

            } else if (xtr.isEndElement() && getElementName().equalsIgnoreCase(xtr.getLocalName())) {
                readyWithFormProperty = true;
            }
        }
    } catch (Exception e) {
        LOGGER.warn("Error parsing form properties child elements", e);
    }

    if (parentElement instanceof UserTask) {
        ((UserTask) parentElement).getFormProperties().add(property);
    } else {
        ((StartEvent) parentElement).getFormProperties().add(property);
    }
}

From source file:org.activiti.bpmn.converter.child.IOSpecificationParser.java

public void parseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
        throws Exception {

    if (parentElement instanceof ServiceTask == false && parentElement instanceof SendTask == false
            && parentElement instanceof SubProcess == false && parentElement instanceof Process == false)
        return;/*from   w w w  .j av a  2  s . com*/

    IOSpecification ioSpecification = new IOSpecification();
    BpmnXMLUtil.addXMLLocation(ioSpecification, xtr);
    boolean readyWithIOSpecification = false;
    try {
        while (readyWithIOSpecification == false && xtr.hasNext()) {
            xtr.next();
            if (xtr.isStartElement() && ELEMENT_DATA_INPUT.equalsIgnoreCase(xtr.getLocalName())) {
                DataSpec dataSpec = new DataSpec();
                BpmnXMLUtil.addXMLLocation(dataSpec, xtr);
                dataSpec.setId(xtr.getAttributeValue(null, ATTRIBUTE_ID));
                dataSpec.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
                dataSpec.setItemSubjectRef(
                        parseItemSubjectRef(xtr.getAttributeValue(null, ATTRIBUTE_DATA_SUBJECT_REF), model));
                ioSpecification.getDataInputs().add(dataSpec);

            } else if (xtr.isStartElement() && ELEMENT_DATA_OUTPUT.equalsIgnoreCase(xtr.getLocalName())) {
                DataSpec dataSpec = new DataSpec();
                BpmnXMLUtil.addXMLLocation(dataSpec, xtr);
                dataSpec.setId(xtr.getAttributeValue(null, ATTRIBUTE_ID));
                dataSpec.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
                dataSpec.setItemSubjectRef(
                        parseItemSubjectRef(xtr.getAttributeValue(null, ATTRIBUTE_DATA_SUBJECT_REF), model));
                ioSpecification.getDataOutputs().add(dataSpec);

            } else if (xtr.isStartElement() && ELEMENT_DATA_INPUT_REFS.equalsIgnoreCase(xtr.getLocalName())) {
                String dataInputRefs = xtr.getElementText();
                if (StringUtils.isNotEmpty(dataInputRefs)) {
                    ioSpecification.getDataInputRefs().add(dataInputRefs.trim());
                }

            } else if (xtr.isStartElement() && ELEMENT_DATA_OUTPUT_REFS.equalsIgnoreCase(xtr.getLocalName())) {
                String dataOutputRefs = xtr.getElementText();
                if (StringUtils.isNotEmpty(dataOutputRefs)) {
                    ioSpecification.getDataOutputRefs().add(dataOutputRefs.trim());
                }

            } else if (xtr.isEndElement() && getElementName().equalsIgnoreCase(xtr.getLocalName())) {
                readyWithIOSpecification = true;
            }
        }
    } catch (Exception e) {
        LOGGER.warn("Error parsing ioSpecification child elements", e);
    }

    if (parentElement instanceof Process) {
        ((Process) parentElement).setIoSpecification(ioSpecification);
    } else {
        ((Activity) parentElement).setIoSpecification(ioSpecification);
    }
}

From source file:org.activiti.bpmn.converter.parser.InterfaceParser.java

public void parse(XMLStreamReader xtr, BpmnModel model) throws Exception {

    Interface interfaceObject = new Interface();
    BpmnXMLUtil.addXMLLocation(interfaceObject, xtr);
    interfaceObject.setId(model.getTargetNamespace() + ":" + xtr.getAttributeValue(null, ATTRIBUTE_ID));
    interfaceObject.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
    interfaceObject.setImplementationRef(
            parseMessageRef(xtr.getAttributeValue(null, ATTRIBUTE_IMPLEMENTATION_REF), model));

    boolean readyWithInterface = false;
    Operation operation = null;//  w w  w  .  j a  v a  2s .c o m
    try {
        while (readyWithInterface == false && xtr.hasNext()) {
            xtr.next();
            if (xtr.isStartElement() && ELEMENT_OPERATION.equals(xtr.getLocalName())) {
                operation = new Operation();
                BpmnXMLUtil.addXMLLocation(operation, xtr);
                operation.setId(model.getTargetNamespace() + ":" + xtr.getAttributeValue(null, ATTRIBUTE_ID));
                operation.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
                operation.setImplementationRef(
                        parseMessageRef(xtr.getAttributeValue(null, ATTRIBUTE_IMPLEMENTATION_REF), model));

            } else if (xtr.isStartElement() && ELEMENT_IN_MESSAGE.equals(xtr.getLocalName())) {
                String inMessageRef = xtr.getElementText();
                if (operation != null && StringUtils.isNotEmpty(inMessageRef)) {
                    operation.setInMessageRef(parseMessageRef(inMessageRef.trim(), model));
                }

            } else if (xtr.isStartElement() && ELEMENT_OUT_MESSAGE.equals(xtr.getLocalName())) {
                String outMessageRef = xtr.getElementText();
                if (operation != null && StringUtils.isNotEmpty(outMessageRef)) {
                    operation.setOutMessageRef(parseMessageRef(outMessageRef.trim(), model));
                }

            } else if (xtr.isEndElement() && ELEMENT_OPERATION.equalsIgnoreCase(xtr.getLocalName())) {
                if (operation != null && StringUtils.isNotEmpty(operation.getImplementationRef())) {
                    interfaceObject.getOperations().add(operation);
                }

            } else if (xtr.isEndElement() && ELEMENT_INTERFACE.equals(xtr.getLocalName())) {
                readyWithInterface = true;
            }
        }
    } catch (Exception e) {
        LOGGER.warn("Error parsing interface child elements", e);
    }

    model.getInterfaces().add(interfaceObject);
}

From source file:org.activiti.designer.eclipse.bpmn.BpmnParser.java

public void parseBpmn(XMLStreamReader xtr, Bpmn2MemoryModel model) {
    try {/*from ww  w.j  av  a 2  s  .  co  m*/
        boolean processExtensionAvailable = false;
        Process activeProcess = null;
        List<SubProcess> activeSubProcessList = new ArrayList<SubProcess>();
        while (xtr.hasNext()) {
            try {
                xtr.next();
            } catch (Exception e) {
                return;
            }

            if (xtr.isEndElement() && "subProcess".equalsIgnoreCase(xtr.getLocalName())) {
                activeSubProcessList.remove(activeSubProcessList.size() - 1);
            }

            if (xtr.isStartElement() == false)
                continue;

            if (xtr.isStartElement() && "definitions".equalsIgnoreCase(xtr.getLocalName())) {

                model.setTargetNamespace(xtr.getAttributeValue(null, "targetNamespace"));

            } else if (xtr.isStartElement() && "signal".equalsIgnoreCase(xtr.getLocalName())) {

                if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, "id"))) {
                    Signal signal = new Signal();
                    signal.setId(xtr.getAttributeValue(null, "id"));
                    signal.setName(xtr.getAttributeValue(null, "name"));
                    model.getSignals().add(signal);
                }

            } else if (xtr.isStartElement() && "participant".equalsIgnoreCase(xtr.getLocalName())) {

                if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, "id"))) {
                    Pool pool = new Pool();
                    pool.setId(xtr.getAttributeValue(null, "id"));
                    pool.setName(xtr.getAttributeValue(null, "name"));
                    pool.setProcessRef(xtr.getAttributeValue(null, "processRef"));
                    model.getPools().add(pool);
                }

            } else if (xtr.isStartElement() && "process".equalsIgnoreCase(xtr.getLocalName())) {

                if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, "id"))) {
                    String processId = xtr.getAttributeValue(null, "id");
                    processExtensionAvailable = true;
                    Process process = new Process();
                    process.setId(processId);
                    process.setName(xtr.getAttributeValue(null, "name"));
                    model.getProcesses().add(process);
                    activeProcess = process;
                }

            } else if (xtr.isStartElement() && "lane".equalsIgnoreCase(xtr.getLocalName())) {
                Lane lane = new Lane();
                lane.setId(xtr.getAttributeValue(null, "id"));
                lane.setName(xtr.getAttributeValue(null, "name"));
                lane.setParentProcess(activeProcess);
                activeProcess.getLanes().add(lane);

                while (xtr.hasNext()) {
                    xtr.next();
                    if (xtr.isStartElement() && "flowNodeRef".equalsIgnoreCase(xtr.getLocalName())) {
                        lane.getFlowReferences().add(xtr.getElementText());
                    } else if (xtr.isEndElement() && "lane".equalsIgnoreCase(xtr.getLocalName())) {
                        break;
                    }
                }

            } else if (xtr.isStartElement() && "documentation".equalsIgnoreCase(xtr.getLocalName())) {

                String docText = xtr.getElementText();
                if (StringUtils.isNotEmpty(docText)) {

                    if (activeSubProcessList.size() > 0) {
                        activeSubProcessList.get(activeSubProcessList.size() - 1).setDocumentation(docText);
                    } else if (activeProcess != null) {
                        activeProcess.setDocumentation(docText);
                    }
                }

            } else if (processExtensionAvailable == true && xtr.isStartElement()
                    && "extensionElements".equalsIgnoreCase(xtr.getLocalName())) {

                activeProcess.getExecutionListeners().addAll(parseListeners(xtr));
                processExtensionAvailable = false;

            } else {

                Artifact currentArtifact = null;
                FlowNode currentActivity = null;
                String elementId = xtr.getAttributeValue(null, "id");
                String elementName = xtr.getAttributeValue(null, "name");
                boolean async = parseAsync(xtr);
                boolean notExclusive = parseNotExclusive(xtr);
                String defaultFlow = xtr.getAttributeValue(null, "default");
                processExtensionAvailable = false;

                if (xtr.isStartElement() && "startEvent".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseStartEvent(xtr);

                } else if (xtr.isStartElement() && "subProcess".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseSubProcess(xtr);
                    activeSubProcessList.add((SubProcess) currentActivity);

                } else if (activeSubProcessList.size() > 0 && xtr.isStartElement()
                        && "extensionElements".equalsIgnoreCase(xtr.getLocalName())) {
                    activeSubProcessList.get(activeSubProcessList.size() - 1).getExecutionListeners()
                            .addAll(parseListeners(xtr));

                } else if (activeSubProcessList.size() > 0 && xtr.isStartElement()
                        && "multiInstanceLoopCharacteristics".equalsIgnoreCase(xtr.getLocalName())) {

                    activeSubProcessList.get(activeSubProcessList.size() - 1)
                            .setLoopCharacteristics(parseMultiInstanceDef(xtr));

                } else if (xtr.isStartElement() && "userTask".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseUserTask(xtr);

                } else if (xtr.isStartElement() && "serviceTask".equalsIgnoreCase(xtr.getLocalName())) {

                    if ("mail".equalsIgnoreCase(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, "type"))) {
                        currentActivity = parseMailTask(xtr, "serviceTask");
                    } else if ("org.alfresco.repo.workflow.activiti.script.AlfrescoScriptDelegate"
                            .equalsIgnoreCase(xtr.getAttributeValue(ACTIVITI_EXTENSIONS_NAMESPACE, "class"))) {
                        currentActivity = parseAlfrescoScriptTask(xtr);
                    } else {
                        currentActivity = parseServiceTask(xtr);
                    }

                } else if (xtr.isStartElement() && "sendTask".equalsIgnoreCase(xtr.getLocalName())) {

                    currentActivity = parseMailTask(xtr, "sendTask");

                } else if (xtr.isStartElement() && "task".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseTask(xtr);

                } else if (xtr.isStartElement() && "scriptTask".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseScriptTask(xtr);

                } else if (xtr.isStartElement() && "manualTask".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseManualTask(xtr);

                } else if (xtr.isStartElement() && "receiveTask".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseReceiveTask(xtr);

                } else if (xtr.isStartElement() && "businessRuleTask".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseBusinessRuleTask(xtr);

                } else if (xtr.isStartElement() && "callActivity".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseCallActivity(xtr);

                } else if (xtr.isStartElement() && "endEvent".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseEndEvent(xtr);

                } else if (xtr.isStartElement()
                        && "intermediateCatchEvent".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseIntermediateCatchEvent(xtr);

                } else if (xtr.isStartElement()
                        && "intermediateThrowEvent".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseIntermediateThrowEvent(xtr);

                } else if (xtr.isStartElement() && "exclusiveGateway".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseExclusiveGateway(xtr);

                } else if (xtr.isStartElement() && "inclusiveGateway".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseInclusiveGateway(xtr);

                } else if (xtr.isStartElement() && "parallelGateway".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseParallelGateway(xtr);

                } else if (xtr.isStartElement() && "eventBasedGateway".equalsIgnoreCase(xtr.getLocalName())) {
                    currentActivity = parseEventGateway(xtr);

                } else if (xtr.isStartElement() && "boundaryEvent".equalsIgnoreCase(xtr.getLocalName())) {
                    String elementid = xtr.getAttributeValue(null, "id");
                    BoundaryEventModel event = parseBoundaryEvent(xtr);
                    event.boundaryEvent.setId(elementid);
                    event.parentProcess = activeProcess;
                    boundaryList.add(event);

                } else if (xtr.isStartElement() && "sequenceFlow".equalsIgnoreCase(xtr.getLocalName())) {
                    SequenceFlowModel sequenceFlow = parseSequenceFlow(xtr);
                    sequenceFlow.parentProcess = activeProcess;
                    sequenceFlowList.add(sequenceFlow);

                } else if (xtr.isStartElement() && "textAnnotation".equalsIgnoreCase(xtr.getLocalName())) {
                    currentArtifact = parseTextAnnotation(xtr);

                } else if (xtr.isStartElement() && "association".equalsIgnoreCase(xtr.getLocalName())) {
                    final AssociationModel associationModel = parseAssociation(xtr);
                    associationModel.parentProcess = activeProcess;
                    associationModels.add(associationModel);

                } else if (xtr.isStartElement() && "BPMNShape".equalsIgnoreCase(xtr.getLocalName())) {
                    bpmdiInfoFound = true;
                    String id = xtr.getAttributeValue(null, "bpmnElement");
                    while (xtr.hasNext()) {
                        xtr.next();
                        if (xtr.isStartElement() && "Bounds".equalsIgnoreCase(xtr.getLocalName())) {
                            GraphicInfo graphicInfo = new GraphicInfo();
                            graphicInfo.x = Double.valueOf(xtr.getAttributeValue(null, "x")).intValue();
                            graphicInfo.y = Double.valueOf(xtr.getAttributeValue(null, "y")).intValue();
                            graphicInfo.height = Double.valueOf(xtr.getAttributeValue(null, "height"))
                                    .intValue();
                            graphicInfo.width = Double.valueOf(xtr.getAttributeValue(null, "width")).intValue();
                            model.addGraphicInfo(id, graphicInfo);
                            break;
                        }
                    }

                } else if (xtr.isStartElement() && "BPMNEdge".equalsIgnoreCase(xtr.getLocalName())) {
                    String id = xtr.getAttributeValue(null, "bpmnElement");
                    List<GraphicInfo> wayPointList = new ArrayList<GraphicInfo>();
                    while (xtr.hasNext()) {
                        xtr.next();
                        if (xtr.isStartElement() && "BPMNLabel".equalsIgnoreCase(xtr.getLocalName())) {

                            while (xtr.hasNext()) {
                                xtr.next();
                                if (xtr.isStartElement() && "Bounds".equalsIgnoreCase(xtr.getLocalName())) {
                                    GraphicInfo graphicInfo = new GraphicInfo();
                                    graphicInfo.x = Double.valueOf(xtr.getAttributeValue(null, "x")).intValue();
                                    graphicInfo.y = Double.valueOf(xtr.getAttributeValue(null, "y")).intValue();
                                    labelLocationMap.put(id, graphicInfo);
                                    break;
                                } else if (xtr.isEndElement()
                                        && "BPMNLabel".equalsIgnoreCase(xtr.getLocalName())) {
                                    break;
                                }
                            }

                        } else if (xtr.isStartElement() && "waypoint".equalsIgnoreCase(xtr.getLocalName())) {
                            GraphicInfo graphicInfo = new GraphicInfo();
                            graphicInfo.x = Double.valueOf(xtr.getAttributeValue(null, "x")).intValue();
                            graphicInfo.y = Double.valueOf(xtr.getAttributeValue(null, "y")).intValue();
                            wayPointList.add(graphicInfo);

                        } else if (xtr.isEndElement() && "BPMNEdge".equalsIgnoreCase(xtr.getLocalName())) {
                            break;
                        }
                    }
                    flowLocationMap.put(id, wayPointList);
                }

                if (currentArtifact != null) {
                    currentArtifact.setId(elementId);

                    if (isInSubProcess(activeSubProcessList)) {
                        final SubProcess currentSubProcess = activeSubProcessList
                                .get(activeSubProcessList.size() - 2);
                        currentSubProcess.getArtifacts().add(currentArtifact);

                    } else {
                        activeProcess.getArtifacts().add(currentArtifact);
                    }
                }

                if (currentActivity != null) {

                    currentActivity.setId(elementId);
                    currentActivity.setName(elementName);

                    if (currentActivity instanceof Activity) {

                        Activity activity = (Activity) currentActivity;
                        activity.setAsynchronous(async);
                        activity.setNotExclusive(notExclusive);
                        if (StringUtils.isNotEmpty(defaultFlow)) {
                            activity.setDefaultFlow(defaultFlow);
                        }
                    }

                    if (currentActivity instanceof Gateway) {
                        if (StringUtils.isNotEmpty(defaultFlow)) {
                            ((Gateway) currentActivity).setDefaultFlow(defaultFlow);
                        }
                    }

                    if (currentActivity instanceof SubProcess) {
                        if (isInSubProcess(activeSubProcessList)) {
                            activeSubProcessList.get(activeSubProcessList.size() - 2).getFlowElements()
                                    .add(currentActivity);

                        } else {
                            activeProcess.getFlowElements().add(currentActivity);
                        }

                    } else if (activeSubProcessList.size() > 0) {
                        activeSubProcessList.get(activeSubProcessList.size() - 1).getFlowElements()
                                .add(currentActivity);
                    } else {
                        activeProcess.getFlowElements().add(currentActivity);
                    }
                }
            }
        }

        for (BoundaryEventModel boundaryModel : boundaryList) {
            FlowNode flowNode = getFlowNode(boundaryModel.attachedRef,
                    boundaryModel.parentProcess.getFlowElements());
            if (flowNode != null) {
                boundaryModel.boundaryEvent.setAttachedToRef((Activity) flowNode);
                ((Activity) flowNode).getBoundaryEvents().add(boundaryModel.boundaryEvent);
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
}