Example usage for javax.xml.stream XMLStreamReader 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:org.ut.biolab.medsavant.client.plugin.PluginIndex.java

public PluginIndex(URL url) throws IOException {
    urls = new HashMap<String, URL>();
    try {//  w w w  .ja v  a2 s  . c o m

        XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(
                ClientNetworkUtils.openStream(url, ClientNetworkUtils.NONCRITICAL_CONNECT_TIMEOUT,
                        ClientNetworkUtils.NONCRITICAL_READ_TIMEOUT));
        if (reader.getVersion() == null) {
            throw new XMLStreamException("Invalid XML at URL " + url);
        }
        boolean done = false;
        String id = null;
        do {
            if (reader.hasNext()) {
                int t = reader.next();
                switch (t) {
                case XMLStreamConstants.START_ELEMENT:
                    String elemName = reader.getLocalName();
                    if (elemName.equals("leaf")) {
                        id = reader.getAttributeValue(null, "id");
                    } else if (elemName.equals("url")) {
                        if (id != null) {
                            try {
                                urls.put(id, new URL(reader.getElementText()));
                            } catch (MalformedURLException x) {
                                LOG.warn(String.format("Unable to parse \"%s\" as a plugin URL.",
                                        reader.getElementText()));
                            }
                            id = null;
                        }
                    }
                    break;
                case XMLStreamConstants.END_DOCUMENT:
                    reader.close();
                    done = true;
                    break;
                }
            } else {
                throw new XMLStreamException("Malformed XML at " + url);
            }
        } while (!done);
    } catch (XMLStreamException x) {
        throw new IOException("Unable to get version number from web-site.", x);
    }
}

---

From source file:org.wso2.carbon.registry.core.jdbc.Repository.java

@SuppressWarnings("deprecation")
private void restoreRecursively(String path, XMLStreamReader xmlReader, DumpReader dumpReader,
        long currentVersion, boolean resourceExists) throws RegistryException, XMLStreamException {
    // we need to check the authorization with the current resource path at this point
    if (!AuthorizationUtils.authorize(path, ActionConstants.PUT)) {
        String msg = "Failed to check-in resource " + path + ". User " + CurrentSession.getUser()
                + " is not authorized to update " + "the current collection path " + path + ".";
        log.warn(msg);//w  w w  .java  2 s . c o m
        throw new AuthorizationFailedException(msg);
    }

    while (!xmlReader.isStartElement() && xmlReader.hasNext()) {
        xmlReader.next();
    }

    if (!xmlReader.hasNext()) {
        // nothing to parse
        return;
    }

    if (!xmlReader.getLocalName().equals(DumpConstants.RESOURCE)) {
        String msg = "Invalid dump to restore at " + path;
        log.error(msg);
        throw new RegistryException(msg);
    }

    String incomingParentPath = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_PATH);
    // the name of the resource is used instead of the path
    String resourceName = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_NAME);
    String ignoreConflictsStrValue = xmlReader.getAttributeValue(null, DumpConstants.IGNORE_CONFLICTS);

    boolean ignoreConflicts = true;
    if (ignoreConflictsStrValue != null && Boolean.toString(false).equals(ignoreConflictsStrValue)) {
        ignoreConflicts = false;
    }

    String isCollectionString = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_IS_COLLECTION);
    boolean isCollection = isCollectionString.equals(DumpConstants.RESOURCE_IS_COLLECTION_TRUE);

    if (path.equals(RegistryConstants.ROOT_PATH) && !isCollection) {
        // you can not put non collection to the root path
        String msg = "Illegal to restore a non-collection in place of root collection.";
        log.error(msg);
        throw new RegistryException(msg);
    }

    String status = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_STATUS);

    //if the status is deleted we delete that resource/collection
    if (DumpConstants.RESOURCE_DELETED.equals(status) && resourceExists) {
        delete(path);
        return;
    }

    ResourceImpl resourceImpl;
    byte[] contentBytes = new byte[0];
    if (isCollection) {
        resourceImpl = new CollectionImpl();
    } else {
        resourceImpl = new ResourceImpl();
    }

    List<CommentDO> commentDOList = new ArrayList<CommentDO>();
    List<TaggingDO> taggingDOList = new ArrayList<TaggingDO>();
    List<RatingDO> ratingDOList = new ArrayList<RatingDO>();
    List<Association> associationList = new ArrayList<Association>();

    boolean isCreatorExisting = false;
    boolean isCreatedTimeExisting = false;
    boolean isUpdaterExisting = false;
    boolean isUpdatedTimeExisting = false;
    long dumpingResourceVersion = -1;

    // traversing to the next element
    do {
        xmlReader.next();
    } while (!xmlReader.isStartElement() && xmlReader.hasNext());

    while (xmlReader.hasNext()) {
        String localName = xmlReader.getLocalName();

        // setMediaType
        if (localName.equals(DumpConstants.MEDIA_TYPE)) {
            String text = xmlReader.getElementText();
            if (text.indexOf('/') < 0) {
                text = MediaTypesUtils.getMediaType("dummy." + text);
            }
            if (text != null) {
                resourceImpl.setMediaType(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // creator
        else if (localName.equals(DumpConstants.CREATOR)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setAuthorUserName(text);
                isCreatorExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // version: just to keep track of the server changes
        else if (localName.equals(DumpConstants.VERSION)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                dumpingResourceVersion = Long.parseLong(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // uuid: just to keep track of the server changes
        else if (localName.equals(DumpConstants.UUID)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setUUID(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // createdTime
        else if (localName.equals(DumpConstants.CREATED_TIME)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                long date = Long.parseLong(text);
                resourceImpl.setCreatedTime(new Date(date));
                isCreatedTimeExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // setLastUpdater
        else if (localName.equals(DumpConstants.LAST_UPDATER)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setLastUpdaterUserName(text);
                isUpdaterExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // LastModified
        else if (localName.equals(DumpConstants.LAST_MODIFIED)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                long date = Long.parseLong(text);
                resourceImpl.setLastModified(new Date(date));
                isUpdatedTimeExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // get description
        else if (localName.equals(DumpConstants.DESCRIPTION)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setDescription(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // get properties
        else if (localName.equals(DumpConstants.PROPERTIES)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.PROPERTY_ENTRY)) {
                String key = xmlReader.getAttributeValue(null, DumpConstants.PROPERTY_ENTRY_KEY);
                String text = xmlReader.getElementText();
                if (text.equals("")) {
                    text = null;
                }
                if (text != null) {
                    resourceImpl.addPropertyWithNoUpdate(key, text);
                }
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            }
        }
        // get content
        else if (localName.equals(DumpConstants.CONTENT)) {
            String text = xmlReader.getElementText();
            // we keep content as base64 encoded
            if (text != null) {
                contentBytes = Base64.decode(text);
            }
            do {
                xmlReader.next();
            } while ((!xmlReader.isStartElement() && xmlReader.hasNext())
                    && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)));
        }
        // getting comment information
        else if (localName.equals(DumpConstants.COMMENTS)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.COMMENT_ENTRY)) {
                CommentDO commentDO = new CommentDO();

                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());

                localName = xmlReader.getLocalName();
                while (xmlReader.hasNext() && (localName.equals(DumpConstants.COMMENT_ENTRY_USER)
                        || localName.equals(DumpConstants.COMMENT_ENTRY_TEXT))) {
                    if (localName.equals(DumpConstants.COMMENT_ENTRY_USER)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            commentDO.setCommentedUser(text);
                        }
                    } else if (localName.equals(DumpConstants.COMMENT_ENTRY_TEXT)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            commentDO.setCommentText(text);
                        }
                    }

                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext());
                    if (xmlReader.hasNext()) {
                        localName = xmlReader.getLocalName();
                    }
                }
                commentDOList.add(commentDO);
            }
        }
        // getting tagging information
        else if (localName.equals(DumpConstants.TAGGINGS)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.TAGGING_ENTRY)) {

                TaggingDO taggingDO = new TaggingDO();

                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());

                localName = xmlReader.getLocalName();
                while (xmlReader.hasNext() && (localName.equals(DumpConstants.TAGGING_ENTRY_USER)
                        || localName.equals(DumpConstants.TAGGING_ENTRY_DATE)
                        || localName.equals(DumpConstants.TAGGING_ENTRY_TAG_NAME))) {
                    if (localName.equals(DumpConstants.TAGGING_ENTRY_USER)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            taggingDO.setTaggedUserName(text);
                        }
                    } else if (localName.equals(DumpConstants.TAGGING_ENTRY_DATE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            long date = Long.parseLong(text);
                            taggingDO.setTaggedTime(new Date(date));
                        }
                    } else if (localName.equals(DumpConstants.TAGGING_ENTRY_TAG_NAME)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            taggingDO.setTagName(text);
                        }
                    }
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext());
                    if (xmlReader.hasNext()) {
                        localName = xmlReader.getLocalName();
                    }
                }
                taggingDOList.add(taggingDO);
            }
        }
        // getting rating information
        else if (localName.equals(DumpConstants.RATINGS)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.RATING_ENTRY)) {
                RatingDO ratingDO = new RatingDO();

                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());

                localName = xmlReader.getLocalName();
                while (xmlReader.hasNext() && (localName.equals(DumpConstants.RATING_ENTRY_USER)
                        || localName.equals(DumpConstants.RATING_ENTRY_DATE)
                        || localName.equals(DumpConstants.RATING_ENTRY_RATE))) {
                    if (localName.equals(DumpConstants.RATING_ENTRY_USER)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            ratingDO.setRatedUserName(text);
                        }
                    } else if (localName.equals(DumpConstants.RATING_ENTRY_DATE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            long date = Long.parseLong(text);
                            ratingDO.setRatedTime(new Date(date));
                        }
                    } else if (localName.equals(DumpConstants.RATING_ENTRY_RATE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            int ratingValue = Integer.parseInt(text);
                            ratingDO.setRating(ratingValue);
                        }
                    }
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext());
                    if (xmlReader.hasNext()) {
                        localName = xmlReader.getLocalName();
                    }
                }
                ratingDOList.add(ratingDO);
            }
        }

        // getting rating information
        else if (localName.equals(DumpConstants.ASSOCIATIONS)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.ASSOCIATION_ENTRY)) {
                String source = null;
                String destination = null;
                String type = null;

                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());

                localName = xmlReader.getLocalName();
                while (xmlReader.hasNext() && (localName.equals(DumpConstants.ASSOCIATION_ENTRY_SOURCE)
                        || localName.equals(DumpConstants.ASSOCIATION_ENTRY_DESTINATION)
                        || localName.equals(DumpConstants.ASSOCIATION_ENTRY_TYPE))) {
                    if (localName.equals(DumpConstants.ASSOCIATION_ENTRY_SOURCE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            source = text;
                        }
                    } else if (localName.equals(DumpConstants.ASSOCIATION_ENTRY_DESTINATION)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            destination = text;
                        }
                    } else if (localName.equals(DumpConstants.ASSOCIATION_ENTRY_TYPE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            type = text;
                        }
                    }
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext());
                    if (xmlReader.hasNext()) {
                        localName = xmlReader.getLocalName();
                    }
                }
                // get the source and destination as absolute paths
                source = RegistryUtils.getAbsoluteAssociationPath(source, path);
                if (destination.startsWith(DumpConstants.EXTERNAL_ASSOCIATION_DESTINATION_PREFIX)) {
                    destination = destination
                            .substring(DumpConstants.EXTERNAL_ASSOCIATION_DESTINATION_PREFIX.length());
                } else {
                    destination = RegistryUtils.getAbsoluteAssociationPath(destination, path);
                }
                associationList.add(new Association(source, destination, type));
            }
        }
        // getting children, just storing in array list now, will used at the end
        // we are keeping old name to keep backward compatibility.
        else if (localName.equals(DumpConstants.CHILDREN) || localName.equals(DumpConstants.CHILDS)) {
            // we keep the stream to call this function recursively
            break;
        } else if (localName.equals(DumpConstants.RESOURCE)) {
            // we keep the stream to call this function recursively
            break;
        } else {
            // we don't mind having unwanted elements, now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
    }
    if (!ignoreConflicts) {
        // so we handling the conflicts.
        if (dumpingResourceVersion > 0) {
            if (currentVersion == -1) {
                // the current version == -1 means the resource is deleted in the server
                // but since the client is sending a version number, it has a previously checkout
                // resource
                String msg = "Resource is deleted in the server, resource path: " + path + ".";
                log.error(msg);
                throw new RegistryException(msg);
            }
            // we should check whether our dump is up-to-date
            if (currentVersion > dumpingResourceVersion) {
                // that mean the current resource is updated before the current version
                // so we have to notify user to get an update
                String msg = "Resource is in a newer version than the restoring version. " + "resource path: "
                        + path + ".";
                log.error(msg);
                throw new RegistryException(msg);
            }
        }
    }

    // completing the empty fields
    if (!isCreatorExisting) {
        String creator = CurrentSession.getUser();
        resourceImpl.setAuthorUserName(creator);
    }
    if (!isCreatedTimeExisting) {
        long now = System.currentTimeMillis();
        resourceImpl.setCreatedTime(new Date(now));
    }
    if (!isUpdaterExisting) {
        String updater = CurrentSession.getUser();
        resourceImpl.setLastUpdaterUserName(updater);
    }
    if (!isUpdatedTimeExisting) {
        long now = System.currentTimeMillis();
        resourceImpl.setLastModified(new Date(now));
    }

    if (resourceImpl.getUUID() == null) {
        setUUIDForResource(resourceImpl);
    }

    // create sym links
    String linkRestoration = resourceImpl.getProperty(RegistryConstants.REGISTRY_LINK_RESTORATION);
    if (linkRestoration != null) {
        String[] parts = linkRestoration.split(RegistryConstants.URL_SEPARATOR);
        if (parts.length == 4) {
            if (parts[2] != null && parts[2].length() == 0) {
                parts[2] = null;
            }
            if (parts[0] != null && parts[1] != null && parts[3] != null) {
                RegistryUtils.registerHandlerForRemoteLinks(RegistryContext.getBaseInstance(), parts[0],
                        parts[1], parts[2], parts[3]);
            }
        } else if (parts.length == 3) {
            // here parts[0] the current path, path[1] is the target path.
            if (parts[0] != null && parts[1] != null) {
                // first we are calculating the relative path of path[1] to path[0]
                String relativeTargetPath = RegistryUtils.getRelativeAssociationPath(parts[1], parts[0]);
                // then we derive the absolute path with reference to the current path.
                String absoluteTargetPath = RegistryUtils.getAbsoluteAssociationPath(relativeTargetPath, path);
                RegistryUtils.registerHandlerForSymbolicLinks(RegistryContext.getBaseInstance(), path,
                        absoluteTargetPath, parts[2]);
            }
        }
    }

    synchronized (this) {
        ResourceIDImpl resourceID = null;
        ResourceDO resourceDO = null;
        if (resourceDAO.resourceExists(path)) {
            resourceID = resourceDAO.getResourceID(path);
            resourceDO = resourceDAO.getResourceDO(resourceID);
            if (resourceDO == null) {
                if (isCollection) {
                    resourceID = resourceDAO.getResourceID(path, isCollection);
                    if (resourceID != null) {
                        resourceDO = resourceDAO.getResourceDO(resourceID);
                    }
                }
                if (resourceDO == null) {
                    return;
                }
            }
        }

        if (DumpConstants.RESOURCE_UPDATED.equals(status) || DumpConstants.RESOURCE_ADDED.equals(status)
                || DumpConstants.RESOURCE_DUMP.equals(status)) {
            if (resourceDAO.resourceExists(path)) {
                if (DumpConstants.RESOURCE_DUMP.equals(status)) {
                    delete(path);
                } else {
                    deleteNode(resourceID, resourceDO, true);
                }
            }
            if (resourceID == null) {
                // need to create a resourceID
                String parentPath = RegistryUtils.getParentPath(path);

                ResourceIDImpl parentResourceID = resourceDAO.getResourceID(parentPath, true);
                if (parentResourceID == null || !resourceDAO.resourceExists(parentResourceID)) {
                    addEmptyCollection(parentPath);
                    if (parentResourceID == null) {
                        parentResourceID = resourceDAO.getResourceID(parentPath, true);
                    }
                }
                resourceDAO.createAndApplyResourceID(path, parentResourceID, resourceImpl);
            } else {
                resourceImpl.setPathID(resourceID.getPathID());
                resourceImpl.setPath(path);
                resourceImpl.setName(resourceID.getName());
            }

            // adding resource followed by content (for nonCollection)
            if (!isCollection) {
                int contentId = 0;
                if (contentBytes.length > 0) {
                    contentId = resourceDAO.addContentBytes(new ByteArrayInputStream(contentBytes));
                }
                resourceImpl.setDbBasedContentID(contentId);
            }

            resourceDO = resourceImpl.getResourceDO();
            resourceDAO.addResourceDO(resourceDO);
            resourceImpl.setVersionNumber(resourceDO.getVersion());

            // adding the properties.
            resourceDAO.addProperties(resourceImpl);

            // adding comments
            commentsDAO.addComments(resourceImpl, commentDOList.toArray(new CommentDO[commentDOList.size()]));

            // adding tags
            tagsDAO.addTaggings(resourceImpl, taggingDOList.toArray(new TaggingDO[taggingDOList.size()]));

            // adding ratings
            ratingsDAO.addRatings(resourceImpl, ratingDOList.toArray(new RatingDO[ratingDOList.size()]));

            for (Association association : associationList) {
                associationDAO.addAssociation(association.getSourcePath(), association.getDestinationPath(),
                        association.getAssociationType());
            }
        }
    }

    if (!xmlReader.hasNext() || !(xmlReader.getLocalName().equals(DumpConstants.CHILDREN)
            || xmlReader.getLocalName().equals(DumpConstants.CHILDS))) {
        // finished the recursion
        return;
    }

    do {
        xmlReader.next();
        if (xmlReader.isEndElement() && (xmlReader.getLocalName().equals(DumpConstants.CHILDREN)
                || xmlReader.getLocalName().equals(DumpConstants.CHILDS))) {
            // this means empty children, just quit from here
            // before that we have to set the cursor to the start of the next element
            if (xmlReader.hasNext()) {
                do {
                    xmlReader.next();
                } while ((!xmlReader.isStartElement() && xmlReader.hasNext()) && !(xmlReader.isEndElement()
                        && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)));
            }
            Resource resource = get(path);
            if (resource instanceof Collection) {
                String[] existingChildren = ((Collection) resource).getChildren();
                for (String existingChild : existingChildren) {
                    delete(existingChild);
                }
            }
            return;
        }
    } while (!xmlReader.isStartElement() && xmlReader.hasNext());

    int i = 0;
    if (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)) {
        Set<String> childPathSet = new HashSet<String>();
        while (true) {
            if (i != 0) {
                dumpReader.setReadingChildResourceIndex(i);

                // otherwise we will set the stuff for the next resource
                // get an xlm reader in the checking child by parent mode.
                xmlReader = XMLInputFactory.newInstance().createXMLStreamReader(dumpReader);

                while (!xmlReader.isStartElement() && xmlReader.hasNext()) {
                    xmlReader.next();
                }
            }

            String absoluteChildPath;
            if (incomingParentPath != null) {
                // the code to support backward compatibility.
                // prepare the children absolute path
                String incomingChildPath = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_PATH);
                /*                    if (!incomingChildPath.startsWith(incomingParentPath)) {
                //break;
                                    }*/

                String relativeChildPath;
                if (incomingParentPath.equals(RegistryConstants.ROOT_PATH)) {
                    relativeChildPath = incomingChildPath;
                } else {
                    if (incomingParentPath.contains(incomingChildPath)) {
                        relativeChildPath = incomingChildPath.substring(incomingParentPath.length());
                    } else {
                        // this happens only at some custom editing of dump.xml
                        relativeChildPath = null;
                    }
                }
                if (relativeChildPath != null) {
                    if (path.equals(RegistryConstants.ROOT_PATH)) {
                        absoluteChildPath = relativeChildPath;
                    } else {
                        absoluteChildPath = path + relativeChildPath;
                    }
                } else {
                    String checkoutRoot = path.substring(0, path.length() - incomingParentPath.length());
                    absoluteChildPath = checkoutRoot + incomingChildPath;
                }
            } else if (resourceName != null) {
                String childName = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_NAME);
                absoluteChildPath = path
                        + (path.equals(RegistryConstants.ROOT_PATH) ? "" : RegistryConstants.PATH_SEPARATOR)
                        + childName;
            } else {
                String msg = "Error in deriving the child paths for collection. path: " + path + ".";
                log.error(msg);
                throw new RegistryException(msg);
            }

            // we give the control back to the child.
            dumpReader.setCheckingChildByParent(false);

            dumpReader.setReadingChildResourceIndex(i);
            // call the check in method recursively

            recursionRepository.restoreRecursively(absoluteChildPath, dumpReader);
            childPathSet.add(absoluteChildPath);

            dumpReader.setCheckingChildByParent(true);
            try {
                if (dumpReader.isLastResource(i)) {
                    dumpReader.setCheckingChildByParent(false);
                    break;
                }
            } catch (IOException e) {
                String msg = "Error in checking the last resource exists.";
                log.error(msg, e);
                throw new RegistryException(msg + e.getMessage(), e);
            }
            // by this time i ++ child resource should exist
            i++;
        }
        Collection parent = (Collection) get(path);
        String[] existingChildren = parent.getChildren();
        for (String existingChild : existingChildren) {
            if (!childPathSet.contains(existingChild)) {
                delete(existingChild);
            }
        }
    }
}

---

From source file:org.wso2.carbon.registry.synchronization.operation.CheckOutCommand.java

private void checkOutRecursively(XMLStreamReader xmlReader, String filePath, String path,
        UserInputCallback callback) throws SynchronizationException, XMLStreamException {
    // we will first generate the axiom node from the reader,
    OMElement root = Utils.readMetaElement(xmlReader);
    // adding path and the registryUrl
    root.addAttribute(DumpConstants.RESOURCE_PATH, path, null);
    if (registryUrl != null) {
        root.addAttribute("registryUrl", registryUrl, null);
    }//from  w  ww . j av a 2s .c o m

    String isCollectionString = root.getAttributeValue(new QName(DumpConstants.RESOURCE_IS_COLLECTION));
    boolean isCollection = isCollectionString.equals("true");

    String name = root.getAttributeValue(new QName(DumpConstants.RESOURCE_NAME));

    byte[] contentBytes = new byte[0];
    File file = new File(filePath);
    boolean overwrite = true;
    boolean fileAlreadyExist = false;

    String parentDirName = file.getAbsoluteFile().getParent();

    String metaDirectoryName;
    String metaFilePath;
    if (isCollection) {
        metaDirectoryName = filePath + File.separator + SynchronizationConstants.META_DIRECTORY;
        metaFilePath = filePath + File.separator + SynchronizationConstants.META_DIRECTORY + File.separator
                + SynchronizationConstants.META_FILE_PREFIX + SynchronizationConstants.META_FILE_EXTENSION;
    } else {
        metaDirectoryName = parentDirName + File.separator + SynchronizationConstants.META_DIRECTORY;
        metaFilePath = parentDirName + File.separator + SynchronizationConstants.META_DIRECTORY + File.separator
                + SynchronizationConstants.META_FILE_PREFIX + Utils.encodeResourceName(name)
                + SynchronizationConstants.META_FILE_EXTENSION;
    }

    if (file.exists()) {
        fileAlreadyExist = true;
    }

    if (!isCollection && fileAlreadyExist) {
        if (!Utils.resourceUpdated(metaFilePath, root) || (callback != null && !callback.getConfirmation(
                new Message(MessageCode.FILE_OVERWRITE_CONFIRMATION, new String[] { filePath }),
                SynchronizationConstants.OVERWRITE_CONFIRMATION_CONTEXT))) {
            overwrite = false;
        }
    }
    try {
        // Create file if it does not exist
        if (isCollection) {
            if (!fileAlreadyExist && Utils.resourceUpdated(metaFilePath, root)) {
                boolean ignore = file.mkdir(); // ignores the return value purposely
            } else {
                overwrite = false;
            }
        } else if (overwrite) {
            boolean ignore = file.createNewFile(); // ignores the return value purposely
        }
    } catch (IOException e) {
        throw new SynchronizationException(MessageCode.FILE_CREATION_FAILED, e,
                new String[] { "file: " + filePath });
    }

    // we are extracting the content from the meta element.
    Iterator children = root.getChildren();
    while (children.hasNext()) {
        OMElement child = (OMElement) children.next();
        String localName = child.getLocalName();

        // LastModified
        if (localName.equals(DumpConstants.LAST_MODIFIED)) {
            OMText text = (OMText) child.getFirstOMChild();
            if (text != null) {
                long date = Long.parseLong(text.getText());
                // We are not bothered whether this failed to set the last-modified time. If we
                // cannot modify the file, we would fail when attempting to write to it anyway.
                boolean ignore = file.setLastModified(date);
            }
        }
        // get content
        else if (localName.equals(DumpConstants.CONTENT)) {
            OMText text = (OMText) child.getFirstOMChild();
            // we keep content as base64 encoded
            if (text != null) {
                contentBytes = Base64.decode(text.getText());
            }
            String md5 = Utils.getMD5(contentBytes);
            root.addAttribute("md5", md5, null);
            child.detach();
        }
    }

    if (!isCollection && overwrite) {
        try {
            FileOutputStream fileStream = null;
            try {
                fileStream = new FileOutputStream(file);
                fileStream.write(contentBytes);
                fileStream.flush();
            } finally {
                if (fileStream != null) {
                    fileStream.close();
                }
            }
        } catch (IOException e) {
            throw new SynchronizationException(MessageCode.PROBLEM_IN_CREATING_CONTENT, e,
                    new String[] { "file: " + filePath });
        }
    }

    // creating the meta directory
    File metaDirectory = new File(metaDirectoryName);
    if (!metaDirectory.exists() && !metaDirectory.mkdir()) {
        throw new SynchronizationException(MessageCode.ERROR_CREATING_META_FILE,
                new String[] { "file: " + metaDirectoryName });
    }

    // creating the meta file
    Utils.createMetaFile(metaFilePath, root);

    // printing out the information of the file
    if (!fileAlreadyExist) {
        if (callback != null) {
            callback.displayMessage(new Message(MessageCode.ADDED, new String[] { filePath }));
        }
        addedCount++;
    } else {
        if (overwrite) {
            if (callback != null) {
                callback.displayMessage(new Message(MessageCode.OVERWRITTEN, new String[] { filePath }));
            }
            overwrittenCount++;
        } else {
            if (callback != null) {
                callback.displayMessage(new Message(MessageCode.NON_OVERWRITTEN, new String[] { filePath }));
            }
            nonOverwrittenCount++;
        }
    }

    if (!xmlReader.hasNext()
            || !(xmlReader.isStartElement() && xmlReader.getLocalName().equals(DumpConstants.CHILDREN))) {
        // finished the recursion
        // consuming the stream until the resource end element found
        while (xmlReader.hasNext()
                && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.RESOURCE))) {
            xmlReader.next();
        }
        return;
    }

    do {
        xmlReader.next();
        if (xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.CHILDREN)) {
            // this means empty children, just quit from here
            // before that we have to set the cursor to the end of the current resource
            if (xmlReader.hasNext()) {
                do {
                    xmlReader.next();
                } while (xmlReader.hasNext() && !(xmlReader.isEndElement()
                        && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)));
            }
            return;
        }
    } while (!xmlReader.isStartElement() && xmlReader.hasNext());

    while (xmlReader.hasNext() && xmlReader.isStartElement()
            && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)) {
        // prepare the children absolute path
        String childName = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_NAME);
        String fileResourceName = childName;
        String childFilePath = filePath + File.separator + fileResourceName;
        String childPath = (path.equals("/") ? "" : path) + "/" + childName;

        checkOutRecursively(xmlReader, childFilePath, childPath, callback);

        while ((!xmlReader.isStartElement() && xmlReader.hasNext())
                && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.CHILDREN))) {
            xmlReader.next();
        }
        if (xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.CHILDREN)) {
            // we are in the end of the children tag.
            break;
        }
    }
    // consuming the stream until the resource end element found
    while (xmlReader.hasNext()
            && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.RESOURCE))) {
        xmlReader.next();
    }
}

---

From source file:org.wso2.carbon.registry.synchronization.operation.UpdateCommand.java

private void updateRecursively(XMLStreamReader xmlReader, String filePath, String path,
        UserInputCallback callback) throws SynchronizationException, XMLStreamException {

    // we will first generate the axiom node from the reader,
    OMElement root = Utils.readMetaElement(xmlReader);
    // adding path and the registryUrl
    root.addAttribute("path", path, null);
    if (registryUrl != null) {
        root.addAttribute("registryUrl", registryUrl, null);
    }/*  w  w w.j ava  2 s  .  c o  m*/

    String isCollectionString = root.getAttributeValue(new QName("isCollection"));
    boolean isCollection = isCollectionString.equals("true");
    String name = root.getAttributeValue(new QName("name"));

    byte[] contentBytes = new byte[0];

    File file = new File(filePath);

    boolean isUpdating = false;
    boolean isConflicting = false;
    boolean collectionIsNotUpdated = false; // valid only for the collection.
    String updatingMD5 = null;
    Iterator children = root.getChildren();
    while (children.hasNext()) {
        OMElement child = (OMElement) children.next();
        String localName = child.getLocalName();

        // get content
        if (localName.equals("content")) {
            OMText text = (OMText) child.getFirstOMChild();
            // we keep content as base64 encoded
            if (text != null) {
                contentBytes = Base64.decode(text.getText());
            }
            updatingMD5 = Utils.getMD5(contentBytes);
            root.addAttribute("md5", updatingMD5, null);
            child.detach();
        }
    }

    // access the meta info of the current
    String metaFilePath;

    if (isCollection) {
        metaFilePath = filePath + File.separator + SynchronizationConstants.META_DIRECTORY + File.separator
                + SynchronizationConstants.META_FILE_PREFIX + SynchronizationConstants.META_FILE_EXTENSION;
    } else {
        String parentDirName = file.getAbsoluteFile().getParent();
        metaFilePath = parentDirName + File.separator + SynchronizationConstants.META_DIRECTORY + File.separator
                + SynchronizationConstants.META_FILE_PREFIX + Utils.encodeResourceName(name)
                + SynchronizationConstants.META_FILE_EXTENSION;
    }

    File metaFile = new File(metaFilePath);

    if (file.exists()) {
        isUpdating = true;
        if (isCollection != file.isDirectory()) {
            throw new SynchronizationException(MessageCode.COLLECTION_AND_RESOURCE_SAME_NAME,
                    new String[] { "file name: " + filePath });
        }

        if (metaFile.exists()) {
            // we need to check the last updated times of the current resource
            // and the updating resource

            OMElement updatingVersionElement = root.getFirstChildWithName(new QName("version"));
            if (updatingVersionElement == null) {
                throw new SynchronizationException(MessageCode.CHECKOUT_OLD_VERSION,
                        new String[] { "missing element: version", "path: " + path });
            }
            String updatingVersionStr = updatingVersionElement.getText();

            // get the meta file OMElement
            OMElement metaFileElement = Utils.getOMElementFromMetaFile(metaFilePath);

            OMElement metaFileVersionElement = metaFileElement.getFirstChildWithName(new QName("version"));

            String metaFileVersionStr;
            if (metaFileVersionElement == null) {
                //Version not defined for the newly added files. They are added when updating.
                metaFileVersionStr = updatingVersionStr;
                root.addAttribute("version", metaFileVersionStr, null);
                Utils.createMetaFile(metaFilePath, root);
            } else {
                metaFileVersionStr = metaFileVersionElement.getText();
            }

            if (isCollection) {
                if (metaFileVersionStr.equals(updatingVersionStr)) {
                    // so there is no server updates for the collection
                    Utils.createMetaFile(metaFilePath, root);
                    collectionIsNotUpdated = true;
                }
            } else {
                // here we not just check server side updates, but also check local changes using md5s
                byte[] currentFileContent = Utils.getBytesFromFile(file);

                String metaFileMD5 = metaFileElement.getAttributeValue(new QName("md5"));
                String currentMD5 = Utils.getMD5(currentFileContent);

                if (metaFileMD5 != null && metaFileMD5.equals(currentMD5)) {
                    // there is no modifications happens to the current file locally,
                    if (metaFileVersionStr.equals(updatingVersionStr)) {
                        // the file in the server is not updated, so just keep the current file locally.
                        // so we are only storing the meta information in the meta file.
                        Utils.createMetaFile(metaFilePath, root);
                        return;
                    }
                    // else:
                    // there is a server update to the file, so lets allow it to update the local one
                    // local one is not updated, so it will be overwritten by the server one
                } else if (metaFileVersionStr.equals(updatingVersionStr)) {
                    // there is no server side changes, but there are client side changes,
                    // just don't update the content, but let the meta file get updated.
                    Utils.createMetaFile(metaFilePath, root);
                    return;
                } else {
                    // this is the following scenario
                    // (!metaFileMD5.equals(currentMD5) &&
                    //    !metaFileVersionStr.equals(updatingVersionStr))
                    if (updatingMD5 != null && !updatingMD5.equals(currentMD5)) {
                        isConflicting = true;
                        root.addAttribute("md5", "", null);
                    }
                }
            }
        } else if (!isCollection) {
            // if there is no meta file exists, that mean there is a conflict
            // a new resource is created both locally and in server
            isConflicting = true;
        }

        if (isConflicting && !isSilentUpdate && !ignoreConflicts) {
            // should rename the current file as file.mine
            String mineFileName = filePath + SynchronizationConstants.MINE_FILE_POSTFIX;
            File mineFile = new File(mineFileName);
            Utils.copy(file, mineFile);

            // updating the current file as versionedFileName
            String versionedFileName = filePath + SynchronizationConstants.SERVER_FILE_POSTFIX;
            file = new File(versionedFileName);

            // set the conflicting flag
            root.addAttribute("conflicting", "true", null);
        }
    } else if (isSilentUpdate) {
        // if no files exists locally, the silent update will return
        return;
    } else if (metaFile.exists()) {
        // now the meta file is there but the direct file is deleted, so we will
        // ask whether he want to get the up. Default behaviour is not to take the update from
        // the server. This is because the working copy is up-to-date.
        if (callback == null || callback.getConfirmation(
                new Message(MessageCode.KEEP_DELETED_FILE, new String[] { filePath }),
                SynchronizationConstants.DELETE_CONFIRMATION_CONTEXT)) {
            return;
        }
    }
    if (!isUpdating) {
        try {
            // Create file if it does not exist
            if (isCollection) {
                boolean ignore = file.mkdir(); // ignores the return value purposely
            } else {
                boolean ignore = file.createNewFile(); // ignores the return value purposely
            }
        } catch (IOException e) {
            throw new SynchronizationException(MessageCode.FILE_CREATION_FAILED, e,
                    new String[] { "file name: " + filePath });
        }
    }

    if (!isCollection) {
        FileOutputStream fileOutputStream = null;
        try {
            boolean writeToFile = true;

            if (file.exists()) {
                byte[] currentContentBytes = Utils.getBytesFromFile(file);
                if (currentContentBytes != null && contentBytes != null) {
                    String currentContentMd5 = Utils.getMD5(currentContentBytes);
                    String writingContentMd5 = Utils.getMD5(contentBytes);
                    if (writingContentMd5 != null && writingContentMd5.equals(currentContentMd5)) {
                        writeToFile = false;
                    }
                }
            }
            if (writeToFile) {
                fileOutputStream = new FileOutputStream(file);
                fileOutputStream.write(contentBytes);
                fileOutputStream.flush();
                fileOutputStream.close();
            }

        } catch (IOException e) {
            throw new SynchronizationException(MessageCode.PROBLEM_IN_CREATING_CONTENT, e,
                    new String[] { "file name: " + filePath });
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                log.error("Failed to close the stream", e);
            }
        }
    } else {
        // creating the meta directory
        String metaDirectoryName = filePath + File.separator + SynchronizationConstants.META_DIRECTORY;
        File metaDirectory = new File(metaDirectoryName);
        if (!metaDirectory.exists() && !metaDirectory.mkdir()) {
            throw new SynchronizationException(MessageCode.ERROR_CREATING_META_FILE,
                    new String[] { "file: " + metaDirectoryName });
        }
    }

    boolean iterateChildren = true;

    if (!xmlReader.hasNext() || !(xmlReader.isStartElement() && xmlReader.getLocalName().equals("children"))) {
        // finished the recursion
        // consuming the stream until the resource end element found
        while (xmlReader.hasNext()
                && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals("resource"))) {
            xmlReader.next();
        }
        iterateChildren = false;
    }
    if (iterateChildren) {
        do {
            xmlReader.next();
            if (xmlReader.isEndElement() && xmlReader.getLocalName().equals("children")) {
                // this means empty children, just quit from here
                // before that we have to set the cursor to the end of the current resource
                if (xmlReader.hasNext()) {
                    do {
                        xmlReader.next();
                    } while (xmlReader.hasNext()
                            && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals("resource")));
                }
                iterateChildren = false;
                break;
            }
        } while (!xmlReader.isStartElement() && xmlReader.hasNext());
    }

    Map<String, Boolean> childNames = new HashMap<String, Boolean>();

    if (iterateChildren) {
        while (xmlReader.hasNext() && xmlReader.isStartElement()
                && xmlReader.getLocalName().equals("resource")) {
            // prepare the children absolute path

            String childName = xmlReader.getAttributeValue(null, "name");
            String fileResourceName = childName;
            String childFilePath = filePath + File.separator + fileResourceName;
            String childPath = (path.equals("/") ? "" : path) + "/" + childName;

            updateRecursively(xmlReader, childFilePath, childPath, callback);
            childNames.put(fileResourceName, true);

            while ((!xmlReader.isStartElement() && xmlReader.hasNext())
                    && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals("children"))) {
                xmlReader.next();
            }
            if (xmlReader.isEndElement() && xmlReader.getLocalName().equals("children")) {
                // we are in the end of the children tag.
                break;
            }
        }
        // consuming the stream until the resource end element found
        while (xmlReader.hasNext()
                && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals("resource"))) {
            xmlReader.next();
        }

        // now we are checking which files have been deleted at the server end.
        String[] childFileNames = file.list();
        if (childFileNames != null) {
            for (String childFileName : childFileNames) {
                if (childFileName.equals(SynchronizationConstants.META_DIRECTORY)) {
                    continue;
                }
                if (childNames.get(childFileName) != null && childNames.get(childFileName)) {
                    // this files stays on the server as well, so nothing to worry
                    continue;
                }
                // hm, we have a situation that stuff exist local, but not at the server
                // first need to check whether they are newly added.
                // we can do that by checking the existence of meta directory
                String childFilePath = file + File.separator + childFileName;
                File childFile = new File(file, childFileName);
                boolean shouldDelete = false;
                File childMetaFile;
                if (childFile.isDirectory()) {
                    // the meta directory should exist in .meta
                    String metaDirName = filePath + File.separator + childFileName + File.separator
                            + SynchronizationConstants.META_DIRECTORY + File.separator + File.separator
                            + SynchronizationConstants.META_FILE_PREFIX
                            + SynchronizationConstants.META_FILE_EXTENSION;
                    childMetaFile = new File(metaDirName);

                    if (childMetaFile.exists()) {
                        // looks like it's bean earlier checkout from registry, mean it is now deleted
                        shouldDelete = true;
                    }
                } else {
                    String metaFileName = filePath + File.separator + SynchronizationConstants.META_DIRECTORY
                            + File.separator + SynchronizationConstants.META_FILE_PREFIX
                            + Utils.encodeResourceName(childFileName)
                            + SynchronizationConstants.META_FILE_EXTENSION;
                    childMetaFile = new File(metaFileName);
                    if (childMetaFile.exists()) {
                        // looks like it's bean earlier checkout from registry, mean it is now deleted
                        shouldDelete = true;
                    }
                }
                if (shouldDelete && !isSilentUpdate) {
                    deleteFile(callback, childFilePath, childFile, childMetaFile);
                }
            }
        }
    } else {
        //            Seems like the user has deleted all the resources under a particular collection

        String[] allFilesNames = file.list();
        if (allFilesNames != null) {
            for (String filesName : allFilesNames) {
                String childFilePath;
                File childFile;
                File childMetaFile;

                childFilePath = filePath + File.separator + filesName;
                childFile = new File(childFilePath);
                if (childFile.isDirectory()) {
                    //                    Here we are deleting all the collections that were deleted from the server
                    String childMetaCollectionPath = childFilePath + File.separator
                            + SynchronizationConstants.META_DIRECTORY;
                    childMetaFile = new File(childMetaCollectionPath);
                    if (childMetaFile.exists() && !isSilentUpdate) {
                        deleteFile(callback, childFilePath, childFile, childMetaFile);
                    }
                } else {
                    //                    Here we remove all the resource that have been deleted from the server
                    String metaFileFullName = filePath + File.separator
                            + SynchronizationConstants.META_DIRECTORY + File.separator
                            + SynchronizationConstants.META_FILE_PREFIX + Utils.encodeResourceName(filesName)
                            + SynchronizationConstants.META_FILE_EXTENSION;

                    childMetaFile = new File(metaFileFullName);
                    if (childMetaFile.exists() && !isSilentUpdate) {
                        deleteFile(callback, childFilePath, childFile, childMetaFile);
                    }
                }
            }
        }
    }

    if (file.isDirectory() && collectionIsNotUpdated) {
        return;
    }

    // creating the meta file
    String metaFileName;
    if (isCollection) {
        metaFileName = filePath + File.separator + SynchronizationConstants.META_DIRECTORY + File.separator
                + SynchronizationConstants.META_FILE_PREFIX + SynchronizationConstants.META_FILE_EXTENSION;
    } else {
        String parentDirName = file.getAbsoluteFile().getParent();
        metaFileName = parentDirName + File.separator + SynchronizationConstants.META_DIRECTORY + File.separator
                + SynchronizationConstants.META_FILE_PREFIX + Utils.encodeResourceName(name)
                + SynchronizationConstants.META_FILE_EXTENSION;
    }
    Utils.createMetaFile(metaFileName, root);

    // printing out the information of the file
    if (isConflicting) {
        if (callback != null && !isSilentUpdate) {
            callback.displayMessage(
                    new Message(MessageCode.CONFLICTED, new String[] { refinedPathToPrint(filePath) }));
        }
        conflictedCount++;
    } else if (isUpdating) {
        if (callback != null && !isSilentUpdate) {
            callback.displayMessage(
                    new Message(MessageCode.UPDATED, new String[] { refinedPathToPrint(filePath) }));
        }
        updatedCount++;
        updated = true;
    } else {
        if (callback != null && !isSilentUpdate) {
            callback.displayMessage(
                    new Message(MessageCode.ADDED, new String[] { refinedPathToPrint(filePath) }));
        }
        addedCount++;
        updated = true;
    }
}

---

From source file:org.wso2.carbon.registry.synchronization.Utils.java

/**
 * This method reads the xml stream up to the children and return the meta element.
 *
 * @param xmlReader the xml reader./*from w w  w.j  a  v a2  s . co  m*/
 *
 * @return the meta element.
 * @throws SynchronizationException if the provided XML is invalid.
 * @throws XMLStreamException       if XML parsing failed.
 */
public static OMElement readMetaElement(XMLStreamReader xmlReader)
        throws SynchronizationException, XMLStreamException {
    try {
        while (!xmlReader.isStartElement() && xmlReader.hasNext()) {
            xmlReader.next();
        }

        if (!xmlReader.hasNext()) {
            // nothing to parse
            return null;
        }

        if (!xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)) {
            throw new SynchronizationException(MessageCode.INVALID_DUMP_CREATE_META_FILE);

        }

        // alerting non-backward compatibility...
        //            String pathAttribute = xmlReader.getAttributeValue(null, ATTR_PATH);
        //            if (pathAttribute != null) {
        //                throw new SynchronizationException(MessageCode.CHECKOUT_OLD_VERSION);
        //            }

        OMFactory factory = OMAbstractFactory.getOMFactory();
        OMElement root = factory.createOMElement(new QName(Utils.ELEM_RESOURCE));

        String resourceName = xmlReader.getAttributeValue(null, ATTR_NAME);
        String isCollectionString = xmlReader.getAttributeValue(null, ATTR_IS_COLLECTION);

        root.addAttribute(ATTR_NAME, resourceName, null);
        root.addAttribute(ATTR_IS_COLLECTION, isCollectionString, null);

        // traversing to the next element
        do {
            xmlReader.next();
        } while (!xmlReader.isStartElement() && xmlReader.hasNext());

        while (xmlReader.hasNext()) {
            String localName = xmlReader.getLocalName();

            // version
            if (localName.equals(ELEM_VERSION)) {
                String text = xmlReader.getElementText();
                OMElement versionElement = factory.createOMElement(new QName(ELEM_VERSION));
                if (text != null) {
                    versionElement.setText(text);
                }
                root.addChild(versionElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // setMediaType
            else if (localName.equals(ELEM_MEDIA_TYPE)) {
                String text = xmlReader.getElementText();
                OMElement mediaTypeElement = factory.createOMElement(new QName(ELEM_MEDIA_TYPE));
                if (text != null) {
                    mediaTypeElement.setText(text);
                }
                root.addChild(mediaTypeElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // creator
            else if (localName.equals(ELEM_CREATOR)) {
                String text = xmlReader.getElementText();
                OMElement creatorElement = factory.createOMElement(new QName(ELEM_CREATOR));
                if (text != null) {
                    creatorElement.setText(text);
                }
                root.addChild(creatorElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // createdTime
            else if (localName.equals(ELEM_CREATED_TIME)) {
                String text = xmlReader.getElementText();
                OMElement createdTimeElement = factory.createOMElement(new QName(ELEM_CREATED_TIME));
                if (text != null) {
                    createdTimeElement.setText(text);
                }
                root.addChild(createdTimeElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // createdTime
            else if (localName.equals(ELEM_CONTENT)) {
                // currently we are keeping the content within the root element, and remove it
                // later. Before Carbon 3.0.0 the content was in the middle of the other
                // resource attributes
                String text = xmlReader.getElementText();
                OMElement contentElement = factory.createOMElement(new QName(ELEM_CONTENT));
                if (text != null) {
                    contentElement.setText(text);
                }
                root.addChild(contentElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // setLastUpdater
            else if (localName.equals(ELEM_LAST_UPDATER)) {
                String text = xmlReader.getElementText();
                OMElement lastUpdaterElement = factory.createOMElement(new QName(ELEM_LAST_UPDATER));
                if (text != null) {
                    lastUpdaterElement.setText(text);
                }
                root.addChild(lastUpdaterElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // LastModified
            else if (localName.equals(ELEM_LAST_MODIFIED)) {
                String text = xmlReader.getElementText();
                OMElement lastModifiedElement = factory.createOMElement(new QName(ELEM_LAST_MODIFIED));
                if (text != null) {
                    lastModifiedElement.setText(text);
                }
                root.addChild(lastModifiedElement);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
            }
            // get description
            else if (localName.equals(ELEM_DESCRIPTION)) {
                String text = xmlReader.getElementText();
                OMElement description = factory.createOMElement(new QName(ELEM_DESCRIPTION));
                if (text != null) {
                    description.setText(text);
                }
                root.addChild(description);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                // now go to the next element while
                // (!xmlReader.isStartElement() && xmlReader.hasNext());
            }
            // get uuid
            else if (localName.equals(ELEM_UUID)) {
                String text = xmlReader.getElementText();
                OMElement description = factory.createOMElement(new QName(ELEM_UUID));
                if (text != null) {
                    description.setText(text);
                }
                root.addChild(description);
                // now go to the next element
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                // now go to the next element while
                // (!xmlReader.isStartElement() && xmlReader.hasNext());
            }
            // get properties
            else if (localName.equals(ELEM_PROPERTIES)) {
                // iterating trying to find the children..
                OMElement properties = factory.createOMElement(new QName(ELEM_PROPERTIES));
                root.addChild(properties);
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                while (xmlReader.hasNext() && xmlReader.getLocalName().equals(ELEM_PROPERTY)) {
                    String key = xmlReader.getAttributeValue(null, ATTR_KEY);
                    String text = xmlReader.getElementText();
                    OMElement property = factory.createOMElement(new QName(ELEM_PROPERTY));
                    property.addAttribute(ATTR_KEY, key, null);
                    properties.addChild(property);

                    if (text.equals("")) {
                        text = null;
                    }
                    if (text != null) {
                        property.setText(text);
                    }
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext() && !(xmlReader.isEndElement()
                            && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                }
                // getting comment information
            } else if (localName.equals(ELEM_COMMENTS)) {
                // iterating trying to find the children..
                OMElement commentsElement = factory.createOMElement(new QName(ELEM_COMMENTS));
                root.addChild(commentsElement);
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());
                while (xmlReader.hasNext() && xmlReader.getLocalName().equals(ELEM_COMMENT)) {
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext() && !(xmlReader.isEndElement()
                            && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));

                    localName = xmlReader.getLocalName();
                    OMElement commentElement = factory.createOMElement(new QName(ELEM_COMMENT));
                    commentsElement.addChild(commentElement);
                    while (xmlReader.hasNext()
                            && (localName.equals(ELEM_USER) || localName.equals(ELEM_TEXT))) {
                        if (localName.equals(ELEM_USER)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement userElement = factory.createOMElement(new QName(ELEM_USER));
                                userElement.setText(text);
                                commentElement.addChild(userElement);
                            }
                        } else if (localName.equals(ELEM_TEXT)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement textElement = factory.createOMElement(new QName(ELEM_TEXT));
                                textElement.setText(text);
                                commentElement.addChild(textElement);
                            }
                        }

                        do {
                            xmlReader.next();
                        } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                                && !(xmlReader.isEndElement()
                                        && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                        if (xmlReader.hasNext()) {
                            localName = xmlReader.getLocalName();
                        }
                    }
                }
            }
            // getting tagging information
            else if (localName.equals(ELEM_TAGGINGS)) {
                // iterating trying to find the children..
                OMElement taggingsElement = factory.createOMElement(new QName(ELEM_TAGGINGS));
                root.addChild(taggingsElement);
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                while (xmlReader.hasNext() && xmlReader.getLocalName().equals(ELEM_TAGGING)) {
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext() && !(xmlReader.isEndElement()
                            && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));

                    localName = xmlReader.getLocalName();

                    OMElement taggingElement = factory.createOMElement(new QName(ELEM_TAGGING));
                    taggingsElement.addChild(taggingElement);

                    while (xmlReader.hasNext() && (localName.equals(ELEM_USER) || localName.equals(ELEM_DATE)
                            || localName.equals(ELEM_TAG_NAME))) {
                        if (localName.equals(ELEM_USER)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement userElement = factory.createOMElement(new QName(ELEM_USER));
                                userElement.setText(text);
                                taggingElement.addChild(userElement);
                            }
                        } else if (localName.equals(ELEM_DATE)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement dateElement = factory.createOMElement(new QName(ELEM_DATE));
                                dateElement.setText(text);
                                taggingElement.addChild(dateElement);
                            }
                        } else if (localName.equals(ELEM_TAG_NAME)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement tagNameElement = factory.createOMElement(new QName(ELEM_TAG_NAME));
                                tagNameElement.setText(text);
                                taggingElement.addChild(tagNameElement);
                            }
                        }
                        do {
                            xmlReader.next();
                        } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                                && !(xmlReader.isEndElement()
                                        && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                        if (xmlReader.hasNext()) {
                            localName = xmlReader.getLocalName();
                        }
                    }
                }
            }
            // getting rating information
            else if (localName.equals(ELEM_RATINGS)) {
                // iterating trying to find the children..
                OMElement ratingsElement = factory.createOMElement(new QName(ELEM_RATINGS));
                root.addChild(ratingsElement);
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                while (xmlReader.hasNext() && xmlReader.getLocalName().equals(ELEM_RATING)) {
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext());

                    localName = xmlReader.getLocalName();

                    OMElement ratingElement = factory.createOMElement(new QName(ELEM_RATING));
                    ratingsElement.addChild(ratingElement);

                    while (xmlReader.hasNext() && (localName.equals(ELEM_USER) || localName.equals(ELEM_DATE)
                            || localName.equals(ELEM_RATE))) {
                        if (localName.equals(ELEM_USER)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement userElement = factory.createOMElement(new QName(ELEM_USER));
                                userElement.setText(text);
                                ratingElement.addChild(userElement);
                            }
                        } else if (localName.equals(ELEM_DATE)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement dateElement = factory.createOMElement(new QName(ELEM_DATE));
                                dateElement.setText(text);
                                ratingElement.addChild(dateElement);
                            }
                        } else if (localName.equals(ELEM_RATE)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement rateElement = factory.createOMElement(new QName(ELEM_RATE));
                                rateElement.setText(text);
                                ratingElement.addChild(rateElement);
                            }
                        }
                        do {
                            xmlReader.next();
                        } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                                && !(xmlReader.isEndElement()
                                        && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                        if (xmlReader.hasNext()) {
                            localName = xmlReader.getLocalName();
                        }
                    }
                }
            }
            // getting rating information
            else if (localName.equals(ELEM_ASSOCIATIONS)) {
                // iterating trying to find the children..
                OMElement associationsElement = factory.createOMElement(new QName(ELEM_ASSOCIATIONS));
                root.addChild(associationsElement);
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                        && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                while (xmlReader.hasNext() && xmlReader.getLocalName().equals(ELEM_ASSOCIATION)) {

                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext() && !(xmlReader.isEndElement()
                            && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));

                    localName = xmlReader.getLocalName();

                    OMElement associationElement = factory.createOMElement(new QName(ELEM_ASSOCIATION));
                    associationsElement.addChild(associationElement);

                    while (xmlReader.hasNext() && (localName.equals(ELEM_SOURCE)
                            || localName.equals(ELEM_DESTINATION) || localName.equals(ELEM_TYPE))) {
                        if (localName.equals(ELEM_SOURCE)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement sourceElement = factory.createOMElement(new QName(ELEM_SOURCE));
                                sourceElement.setText(text);
                                associationElement.addChild(sourceElement);
                            }
                        } else if (localName.equals(ELEM_DESTINATION)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement destinationElement = factory
                                        .createOMElement(new QName(ELEM_DESTINATION));
                                destinationElement.setText(text);
                                associationElement.addChild(destinationElement);
                            }
                        } else if (localName.equals(ELEM_TYPE)) {
                            String text = xmlReader.getElementText();
                            if (text != null) {
                                OMElement typeElement = factory.createOMElement(new QName(ELEM_TYPE));
                                typeElement.setText(text);
                                associationElement.addChild(typeElement);
                            }
                        }
                        do {
                            xmlReader.next();
                        } while (!xmlReader.isStartElement() && xmlReader.hasNext()
                                && !(xmlReader.isEndElement()
                                        && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE)));
                        if (xmlReader.hasNext()) {
                            localName = xmlReader.getLocalName();
                        }
                    }
                }
            } else if (localName.equals(ELEM_CHILDREN) || localName.equals(Utils.ELEM_RESOURCE)) {
                // checking the children or content element to terminate the check.
                break;
            } else {
                // we do mind having unwanted elements, now go to the next element
                break;
            }

            if ((xmlReader.isEndElement() && xmlReader.getLocalName().equals(Utils.ELEM_RESOURCE))) {
                // here we come the end of the resource tag
                break;
            }
        }
        return root;
    } catch (XMLStreamException e) {
        throw new SynchronizationException(MessageCode.ERROR_IN_READING_STREAM_TO_CREATE_META_FILE, e);
    }
}

---

From source file:org.wso2.carbon.repository.core.ResourceStorer.java

private void restoreRecursively(String path, XMLStreamReader xmlReader, DumpReader dumpReader,
        long currentVersion, boolean resourceExists) throws RepositoryException, XMLStreamException {
    while (!xmlReader.isStartElement() && xmlReader.hasNext()) {
        xmlReader.next();//from   ww w  .j  a  va 2s.  c  o m
    }

    if (!xmlReader.hasNext()) {
        return;
    }

    if (!xmlReader.getLocalName().equals(DumpConstants.RESOURCE)) {
        String msg = "Invalid dump to restore at " + path;
        log.error(msg);
        throw new RepositoryException(msg);
    }

    String incomingParentPath = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_PATH);

    String resourceName = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_NAME);
    String ignoreConflictsStrValue = xmlReader.getAttributeValue(null, DumpConstants.IGNORE_CONFLICTS);

    boolean ignoreConflicts = true;

    if (ignoreConflictsStrValue != null && Boolean.toString(false).equals(ignoreConflictsStrValue)) {
        ignoreConflicts = false;
    }

    String isCollectionString = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_IS_COLLECTION);
    boolean isCollection = isCollectionString.equals(DumpConstants.RESOURCE_IS_COLLECTION_TRUE);

    if (path.equals(RepositoryConstants.ROOT_PATH) && !isCollection) {
        String msg = "Illegal to restore a non-collection in place of root collection.";
        log.error(msg);
        throw new RepositoryException(msg);
    }

    String status = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_STATUS);

    if (DumpConstants.RESOURCE_DELETED.equals(status) && resourceExists) {
        delete(path);
        return;
    }

    ResourceImpl resourceImpl;
    byte[] contentBytes = new byte[0];

    if (isCollection) {
        resourceImpl = new CollectionImpl();
    } else {
        resourceImpl = new ResourceImpl();
    }

    boolean isCreatorExisting = false;
    boolean isCreatedTimeExisting = false;
    boolean isUpdaterExisting = false;
    boolean isUpdatedTimeExisting = false;
    long dumpingResourceVersion = -1;

    do {
        xmlReader.next();
    } while (!xmlReader.isStartElement() && xmlReader.hasNext());

    while (xmlReader.hasNext()) {
        String localName = xmlReader.getLocalName();

        // setMediaType
        if (localName.equals(DumpConstants.MEDIA_TYPE)) {
            String text = xmlReader.getElementText();
            if (text.indexOf('/') < 0) {
                text = MediaTypesUtils.getMediaType("dummy." + text);
            }
            if (text != null) {
                resourceImpl.setMediaType(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        } else if (localName.equals(DumpConstants.CREATOR)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setAuthorUserName(text);
                isCreatorExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // version: just to keep track of the server changes
        else if (localName.equals(DumpConstants.VERSION)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                dumpingResourceVersion = Long.parseLong(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // uuid: just to keep track of the server changes
        else if (localName.equals(DumpConstants.UUID)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setUUID(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // createdTime
        else if (localName.equals(DumpConstants.CREATED_TIME)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                long date = Long.parseLong(text);
                resourceImpl.setCreatedTime(new Date(date));
                isCreatedTimeExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // setLastUpdater
        else if (localName.equals(DumpConstants.LAST_UPDATER)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setLastUpdaterUserName(text);
                isUpdaterExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // LastModified
        else if (localName.equals(DumpConstants.LAST_MODIFIED)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                long date = Long.parseLong(text);
                resourceImpl.setLastModified(new Date(date));
                isUpdatedTimeExisting = true;
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // get description
        else if (localName.equals(DumpConstants.DESCRIPTION)) {
            String text = xmlReader.getElementText();
            if (text != null) {
                resourceImpl.setDescription(text);
            }
            // now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
        // get properties
        else if (localName.equals(DumpConstants.PROPERTIES)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.PROPERTY_ENTRY)) {
                String key = xmlReader.getAttributeValue(null, DumpConstants.PROPERTY_ENTRY_KEY);
                String text = xmlReader.getElementText();
                if (text.equals("")) {
                    text = null;
                }
                if (text != null) {
                    resourceImpl.addPropertyWithNoUpdate(key, text);
                }
                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            }
        }
        // get content
        else if (localName.equals(DumpConstants.CONTENT)) {
            String text = xmlReader.getElementText();
            // we keep content as base64 encoded
            if (text != null) {
                contentBytes = DatatypeConverter.parseBase64Binary(text);
            }
            do {
                xmlReader.next();
            } while ((!xmlReader.isStartElement() && xmlReader.hasNext())
                    && !(xmlReader.isEndElement() && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)));
        }

        // getting rating information
        else if (localName.equals(DumpConstants.ASSOCIATIONS)) {
            // iterating trying to find the children..
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
            while (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.ASSOCIATION_ENTRY)) {
                String source = null;
                String destination = null;
                String type = null;

                do {
                    xmlReader.next();
                } while (!xmlReader.isStartElement() && xmlReader.hasNext());

                localName = xmlReader.getLocalName();
                while (xmlReader.hasNext() && (localName.equals(DumpConstants.ASSOCIATION_ENTRY_SOURCE)
                        || localName.equals(DumpConstants.ASSOCIATION_ENTRY_DESTINATION)
                        || localName.equals(DumpConstants.ASSOCIATION_ENTRY_TYPE))) {
                    if (localName.equals(DumpConstants.ASSOCIATION_ENTRY_SOURCE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            source = text;
                        }
                    } else if (localName.equals(DumpConstants.ASSOCIATION_ENTRY_DESTINATION)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            destination = text;
                        }
                    } else if (localName.equals(DumpConstants.ASSOCIATION_ENTRY_TYPE)) {
                        String text = xmlReader.getElementText();
                        if (text != null) {
                            type = text;
                        }
                    }
                    do {
                        xmlReader.next();
                    } while (!xmlReader.isStartElement() && xmlReader.hasNext());
                    if (xmlReader.hasNext()) {
                        localName = xmlReader.getLocalName();
                    }
                }
                // get the source and destination as absolute paths
                source = RepositoryUtils.getAbsoluteAssociationPath(source, path);
                if (destination.startsWith(DumpConstants.EXTERNAL_ASSOCIATION_DESTINATION_PREFIX)) {
                    destination = destination
                            .substring(DumpConstants.EXTERNAL_ASSOCIATION_DESTINATION_PREFIX.length());
                } else {
                    destination = RepositoryUtils.getAbsoluteAssociationPath(destination, path);
                }
                //                    associationList.add(new Association(source, destination, type));
            }
        }

        // getting children, just storing in array list now, will used at the end
        // we are keeping old name to keep backward compatibility.
        else if (localName.equals(DumpConstants.CHILDREN) || localName.equals(DumpConstants.CHILDS)) {
            // we keep the stream to call this function recursively
            break;
        } else if (localName.equals(DumpConstants.RESOURCE)) {
            // we keep the stream to call this function recursively
            break;
        } else {
            // we don't mind having unwanted elements, now go to the next element
            do {
                xmlReader.next();
            } while (!xmlReader.isStartElement() && xmlReader.hasNext());
        }
    }

    if (!ignoreConflicts) {
        // so we handling the conflicts.
        if (dumpingResourceVersion > 0) {
            if (currentVersion == -1) {
                // the current version == -1 means the resource is deleted in the server
                // but since the client is sending a version number, it has a previously checkout
                // resource
                String msg = "Resource is deleted in the server, resource path: " + path + ".";
                log.error(msg);
                throw new RepositoryException(msg);
            }
            // we should check whether our dump is up-to-date
            if (currentVersion > dumpingResourceVersion) {
                // that mean the current resource is updated before the current version
                // so we have to notify user to get an update
                String msg = "Resource is in a newer version than the restoring version. " + "resource path: "
                        + path + ".";
                log.error(msg);
                throw new RepositoryException(msg);
            }
        }
    }

    // completing the empty fields
    if (!isCreatorExisting) {
        String creator = CurrentContext.getUser();
        resourceImpl.setAuthorUserName(creator);
    }

    if (!isCreatedTimeExisting) {
        long now = System.currentTimeMillis();
        resourceImpl.setCreatedTime(new Date(now));
    }

    if (!isUpdaterExisting) {
        String updater = CurrentContext.getUser();
        resourceImpl.setLastUpdaterUserName(updater);
    }

    if (!isUpdatedTimeExisting) {
        long now = System.currentTimeMillis();
        resourceImpl.setLastModified(new Date(now));
    }

    if (resourceImpl.getUUID() == null) {
        setUUIDForResource(resourceImpl);
    }

    // create sym links
    String linkRestoration = resourceImpl.getPropertyValue(InternalConstants.REGISTRY_LINK_RESTORATION);
    if (linkRestoration != null) {
        String[] parts = linkRestoration.split(RepositoryConstants.URL_SEPARATOR);

        if (parts.length == 4) {
            if (parts[2] != null && parts[2].length() == 0) {
                parts[2] = null;
            }
            if (parts[0] != null && parts[1] != null && parts[3] != null) {
                InternalUtils.registerHandlerForRemoteLinks(RepositoryContext.getBaseInstance(), parts[0],
                        parts[1], parts[2], parts[3]);
            }
        } else if (parts.length == 3) {
            // here parts[0] the current path, path[1] is the target path.
            if (parts[0] != null && parts[1] != null) {
                // first we are calculating the relative path of path[1] to path[0]
                String relativeTargetPath = RepositoryUtils.getRelativeAssociationPath(parts[1], parts[0]);
                // then we derive the absolute path with reference to the current path.
                String absoluteTargetPath = RepositoryUtils.getAbsoluteAssociationPath(relativeTargetPath,
                        path);
                InternalUtils.registerHandlerForSymbolicLinks(RepositoryContext.getBaseInstance(), path,
                        absoluteTargetPath, parts[2]);
            }
        }
    }

    synchronized (this) {
        ResourceIDImpl resourceID = null;
        ResourceDO resourceDO = null;

        if (resourceDAO.resourceExists(path)) {
            resourceID = resourceDAO.getResourceID(path);
            resourceDO = resourceDAO.getResourceDO(resourceID);

            if (resourceDO == null) {
                if (isCollection) {
                    resourceID = resourceDAO.getResourceID(path, isCollection);

                    if (resourceID != null) {
                        resourceDO = resourceDAO.getResourceDO(resourceID);
                    }
                }

                if (resourceDO == null) {
                    return;
                }
            }
        }

        if (DumpConstants.RESOURCE_UPDATED.equals(status) || DumpConstants.RESOURCE_ADDED.equals(status)
                || DumpConstants.RESOURCE_DUMP.equals(status)) {
            if (resourceDAO.resourceExists(path)) {
                if (DumpConstants.RESOURCE_DUMP.equals(status)) {
                    delete(path);
                } else {
                    deleteNode(resourceID, resourceDO, true);
                }
            }

            if (resourceID == null) {
                // need to create a resourceID
                String parentPath = RepositoryUtils.getParentPath(path);

                ResourceIDImpl parentResourceID = resourceDAO.getResourceID(parentPath, true);
                if (parentResourceID == null || !resourceDAO.resourceExists(parentResourceID)) {
                    addEmptyCollection(parentPath);
                    if (parentResourceID == null) {
                        parentResourceID = resourceDAO.getResourceID(parentPath, true);
                    }
                }
                resourceDAO.createAndApplyResourceID(path, parentResourceID, resourceImpl);
            } else {
                resourceImpl.setPathID(resourceID.getPathID());
                resourceImpl.setName(resourceID.getName());
                resourceImpl.setPath(path);
            }

            // adding resource followed by content (for nonCollection)
            if (!isCollection) {
                int contentId = 0;

                if (contentBytes.length > 0) {
                    contentId = resourceDAO.addContentBytes(new ByteArrayInputStream(contentBytes));
                }

                resourceImpl.setDbBasedContentID(contentId);
            }

            resourceDO = resourceImpl.getResourceDO();
            resourceDAO.addResourceDO(resourceDO);
            resourceImpl.setVersionNumber(resourceDO.getVersion());

            // adding the properties.
            resourceDAO.addProperties(resourceImpl);
        }
    }

    if (!xmlReader.hasNext() || !(xmlReader.getLocalName().equals(DumpConstants.CHILDREN)
            || xmlReader.getLocalName().equals(DumpConstants.CHILDS))) {
        // finished the recursion
        return;
    }

    do {
        xmlReader.next();
        if (xmlReader.isEndElement() && (xmlReader.getLocalName().equals(DumpConstants.CHILDREN)
                || xmlReader.getLocalName().equals(DumpConstants.CHILDS))) {
            // this means empty children, just quit from here
            // before that we have to set the cursor to the start of the next element
            if (xmlReader.hasNext()) {
                do {
                    xmlReader.next();
                } while ((!xmlReader.isStartElement() && xmlReader.hasNext()) && !(xmlReader.isEndElement()
                        && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)));
            }
            Resource resource = get(path);

            if (resource instanceof Collection) {
                String[] existingChildren = ((Collection) resource).getChildPaths();
                for (String existingChild : existingChildren) {
                    delete(existingChild);
                }
            }

            return;
        }
    } while (!xmlReader.isStartElement() && xmlReader.hasNext());

    int i = 0;

    if (xmlReader.hasNext() && xmlReader.getLocalName().equals(DumpConstants.RESOURCE)) {
        Set<String> childPathSet = new HashSet<String>();

        while (true) {
            if (i != 0) {
                dumpReader.setReadingChildResourceIndex(i);

                // otherwise we will set the stuff for the next resource
                // get an xlm reader in the checking child by parent mode.
                xmlReader = XMLInputFactory.newInstance().createXMLStreamReader(dumpReader);

                while (!xmlReader.isStartElement() && xmlReader.hasNext()) {
                    xmlReader.next();
                }
            }

            String absoluteChildPath;

            if (incomingParentPath != null) {
                // the code to support backward compatibility.
                // prepare the children absolute path
                String incomingChildPath = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_PATH);
                /*                    if (!incomingChildPath.startsWith(incomingParentPath)) {
                //break;
                                    }*/

                String relativeChildPath;

                if (incomingParentPath.equals(RepositoryConstants.ROOT_PATH)) {
                    relativeChildPath = incomingChildPath;
                } else {
                    if (incomingParentPath.contains(incomingChildPath)) {
                        relativeChildPath = incomingChildPath.substring(incomingParentPath.length());
                    } else {
                        // this happens only at some custom editing of dump.xml
                        relativeChildPath = null;
                    }
                }
                if (relativeChildPath != null) {
                    if (path.equals(RepositoryConstants.ROOT_PATH)) {
                        absoluteChildPath = relativeChildPath;
                    } else {
                        absoluteChildPath = path + relativeChildPath;
                    }
                } else {
                    String checkoutRoot = path.substring(0, path.length() - incomingParentPath.length());
                    absoluteChildPath = checkoutRoot + incomingChildPath;
                }
            } else if (resourceName != null) {
                String childName = xmlReader.getAttributeValue(null, DumpConstants.RESOURCE_NAME);
                absoluteChildPath = path
                        + (path.equals(RepositoryConstants.ROOT_PATH) ? "" : RepositoryConstants.PATH_SEPARATOR)
                        + childName;
            } else {
                String msg = "Error in deriving the child paths for collection. path: " + path + ".";
                log.error(msg);
                throw new RepositoryException(msg);
            }

            // we give the control back to the child.
            dumpReader.setCheckingChildByParent(false);

            dumpReader.setReadingChildResourceIndex(i);
            // call the check in method recursively

            recursionRepository.restoreRecursively(absoluteChildPath, dumpReader);
            childPathSet.add(absoluteChildPath);

            dumpReader.setCheckingChildByParent(true);

            try {
                if (dumpReader.isLastResource(i)) {
                    dumpReader.setCheckingChildByParent(false);
                    break;
                }
            } catch (IOException e) {
                String msg = "Error in checking the last resource exists.";
                log.error(msg, e);
                throw new RepositoryException(msg + e.getMessage(), e);
            }
            // by this time i ++ child resource should exist
            i++;
        }

        Collection parent = (Collection) get(path);
        String[] existingChildren = parent.getChildPaths();

        for (String existingChild : existingChildren) {
            if (!childPathSet.contains(existingChild)) {
                delete(existingChild);
            }
        }
    }
}

---

From source file:pl.datamatica.traccar.api.GPXParser.java

public Result parse(InputStream inputStream, Device device)
        throws XMLStreamException, ParseException, IOException {
    Result result = new Result();

    TimeZone tz = TimeZone.getTimeZone("UTC");
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
    DateFormat dateFormatWithMS = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");

    dateFormat.setTimeZone(tz);//  w  w  w  .j a  v a 2 s.  co  m
    dateFormatWithMS.setTimeZone(tz);

    XMLStreamReader xsr = XMLInputFactory.newFactory().createXMLStreamReader(inputStream);
    ObjectMapper jsonMapper = new ObjectMapper();

    result.positions = new LinkedList<>();
    Position position = null;
    Stack<String> extensionsElements = new Stack<>();
    boolean extensionsStarted = false;
    Map<String, Object> other = null;

    while (xsr.hasNext()) {
        xsr.next();
        if (xsr.getEventType() == XMLStreamReader.START_ELEMENT) {
            if (xsr.getLocalName().equalsIgnoreCase("trkpt")) {
                position = new Position();
                position.setLongitude(Double.parseDouble(xsr.getAttributeValue(null, "lon")));
                position.setLatitude(Double.parseDouble(xsr.getAttributeValue(null, "lat")));
                position.setValid(Boolean.TRUE);
                position.setDevice(device);
            } else if (xsr.getLocalName().equalsIgnoreCase("time")) {
                if (position != null) {
                    String strTime = xsr.getElementText();
                    if (strTime.length() == 20) {
                        position.setTime(dateFormat.parse(strTime));
                    } else {
                        position.setTime(dateFormatWithMS.parse(strTime));
                    }
                }
            } else if (xsr.getLocalName().equalsIgnoreCase("ele") && position != null) {
                position.setAltitude(Double.parseDouble(xsr.getElementText()));
            } else if (xsr.getLocalName().equalsIgnoreCase("address") && position != null) {
                position.setAddress(StringEscapeUtils.unescapeXml(xsr.getElementText()));
            } else if (xsr.getLocalName().equalsIgnoreCase("protocol") && position != null) {
                position.setProtocol(xsr.getElementText());
            } else if (xsr.getLocalName().equalsIgnoreCase("speed") && position != null) {
                position.setSpeed(Double.parseDouble(xsr.getElementText()));
            } else if (xsr.getLocalName().equalsIgnoreCase("power") && position != null) {
                position.setPower(Double.parseDouble(xsr.getElementText()));
            } else if (xsr.getLocalName().equalsIgnoreCase("course") && position != null) {
                position.setCourse(Double.parseDouble(xsr.getElementText()));
            } else if (xsr.getLocalName().equalsIgnoreCase("other") && position != null) {
                position.setOther(StringEscapeUtils.unescapeXml(xsr.getElementText()));
            } else if (xsr.getLocalName().equalsIgnoreCase("extensions")) {
                other = new LinkedHashMap<>();
                extensionsStarted = true;
            } else if (position != null && extensionsStarted && other != null) {
                extensionsElements.push(xsr.getLocalName());
            }
        } else if (xsr.getEventType() == XMLStreamReader.END_ELEMENT) {
            if (xsr.getLocalName().equalsIgnoreCase("trkpt")) {
                if (other == null) {
                    other = new HashMap<>();
                }

                if (position.getOther() != null) {
                    if (position.getOther().startsWith("<")) {
                        XMLStreamReader otherReader = XMLInputFactory.newFactory()
                                .createXMLStreamReader(new StringReader(position.getOther()));
                        while (otherReader.hasNext()) {
                            if (otherReader.next() == XMLStreamReader.START_ELEMENT
                                    && !otherReader.getLocalName().equals("info")) {
                                other.put(otherReader.getLocalName(), otherReader.getElementText());
                            }
                        }
                    } else {
                        Map<String, Object> parsedOther = jsonMapper.readValue(position.getOther(),
                                LinkedHashMap.class);
                        other.putAll(parsedOther);
                    }
                }

                if (other.containsKey("protocol") && position.getProtocol() == null) {
                    position.setProtocol(other.get("protocol").toString());
                } else if (!other.containsKey("protocol") && position.getProtocol() == null) {
                    position.setProtocol("gpx_import");
                }

                other.put("import_type", (result.positions.isEmpty() ? "import_start" : "import"));

                position.setOther(jsonMapper.writeValueAsString(other));

                result.positions.add(position);
                if (result.latestPosition == null
                        || result.latestPosition.getTime().compareTo(position.getTime()) < 0) {
                    result.latestPosition = position;
                }
                position = null;
                other = null;
            } else if (xsr.getLocalName().equalsIgnoreCase("extensions")) {
                extensionsStarted = false;
            } else if (extensionsStarted) {
                extensionsElements.pop();
            }
        } else if (extensionsStarted && other != null && xsr.getEventType() == XMLStreamReader.CHARACTERS
                && !xsr.getText().trim().isEmpty() && !extensionsElements.empty()) {
            String name = "";
            for (int i = 0; i < extensionsElements.size(); i++) {
                name += (name.length() > 0 ? "-" : "") + extensionsElements.get(i);
            }

            other.put(name, xsr.getText());
        }
    }

    if (result.positions.size() > 1) {
        Position last = ((LinkedList<Position>) result.positions).getLast();
        Map<String, Object> parsedOther = jsonMapper.readValue(last.getOther(), LinkedHashMap.class);
        parsedOther.put("import_type", "import_end");
        last.setOther(jsonMapper.writeValueAsString(parsedOther));
    }

    return result;
}

---

From source file:rjc.jplanner.model.Plan.java

/******************************************* loadXML *******************************************/
public void loadXML(XMLStreamReader xsr, String filename, String fileloc) throws XMLStreamException {
    // as id of plan-calendar read before the calendars, need temporary store
    int calendarId = -1;

    // load plan from XML stream
    while (xsr.hasNext()) {
        // if reached end of plan data, exit loop
        if (xsr.isEndElement() && xsr.getLocalName().equals(XmlLabels.XML_PLAN_DATA))
            break;

        // if start element read data
        if (xsr.isStartElement())
            switch (xsr.getLocalName()) {
            case XmlLabels.XML_JPLANNER:
                loadXmlJPlanner(xsr);//from  www. jav a 2s.c o m
                break;
            case XmlLabels.XML_PLAN_DATA:
                calendarId = loadXmlPlan(xsr);
                break;
            case XmlLabels.XML_DAY_DATA:
                daytypes.loadXML(xsr);
                break;
            case XmlLabels.XML_CAL_DATA:
                calendars.loadXML(xsr);
                break;
            case XmlLabels.XML_RES_DATA:
                resources.loadXML(xsr);
                break;
            case XmlLabels.XML_TASK_DATA:
                tasks.loadXML(xsr);
                break;
            default:
                JPlanner.trace("Unhandled start element '" + xsr.getLocalName() + "'");
                break;
            }

        xsr.next();
    }

    // if calendar-id still negative, default to first calendar
    if (calendarId < 0)
        m_calendar = calendar(0);
    else
        m_calendar = calendar(calendarId);

    m_filename = filename;
    m_fileLocation = fileloc;
}

---

From source file:tkwatch.Utilities.java

/**
 * Finds the value of the named element, if any, in an XML string. Adapted
 * from Vohra and Vohra, <i>Pro XML Development with Java Technology</i>, p.
 * 47./*from   w w  w .  j  av a2  s . co m*/
 * 
 * @param desiredElementName
 *            The name of the element to search for in the XML string.
 * @param xmlString
 *            The XML string to search for an account number.
 * 
 * @return Returns the element value(s) as formatted in the incoming string
 *         (if found) as a <code>Vector<String></code>, <code>null</code>
 *         otherwise.
 */
public static final Vector<String> getValueFromXml(final String desiredElementName, final String xmlString) {
    Vector<String> elementValue = new Vector<String>();
    String elementValueText = null;
    XMLInputFactory inputFactory = XMLInputFactory.newInstance();
    try {
        String elementName = "";
        StringReader stringReader = new StringReader(xmlString);
        XMLStreamReader reader = inputFactory.createXMLStreamReader(stringReader);
        while (reader.hasNext()) {
            int eventType = reader.getEventType();
            switch (eventType) {
            case XMLStreamConstants.START_ELEMENT:
                elementName = reader.getLocalName();
                if (elementName.equals(desiredElementName)) {
                    elementValueText = reader.getAttributeValue(0);
                    System.out.println("START_ELEMENT case, element name is " + elementName
                            + ", element value is " + elementValueText);
                }
                break;
            case XMLStreamConstants.ATTRIBUTE:
                elementName = reader.getLocalName();
                if (elementName.equals(desiredElementName)) {
                    elementValueText = reader.getElementText();
                    System.out.println("ATTRIBUTE case, element name is " + elementName + ", element value is "
                            + elementValueText);
                    elementValue.add(elementValueText);
                }
                break;
            case XMLStreamConstants.END_ELEMENT:
                elementName = reader.getLocalName();
                if (elementName.equals(desiredElementName)) {
                    System.out.println("END_ELEMENT case, element name is " + elementName
                            + ", element value is " + elementValueText);
                }
                break;
            default:
                elementName = reader.getLocalName();
                if (elementName != null) {
                    if (elementName.equals(desiredElementName)) {
                        System.out.println("default case, element name is " + elementName);
                    }
                }
                break;
            }
            reader.next();
        }
    } catch (XMLStreamException e) {
        TradekingException.handleException(e);
    }
    return (elementValue.isEmpty() ? null : elementValue);
}

---

From source file:tpt.dbweb.cat.io.TaggedTextXMLReader.java

private Iterator<TaggedText> getIterator(InputStream is, String errorMessageInfo) {

    XMLStreamReader tmpxsr = null;
    try {/*from www.ja v a2  s  .  c o m*/
        XMLInputFactory xif = XMLInputFactory.newInstance();
        xif.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
        xif.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, false);
        xif.setProperty(XMLInputFactory.IS_VALIDATING, false);
        tmpxsr = xif.createXMLStreamReader(is);
    } catch (XMLStreamException | FactoryConfigurationError e) {
        e.printStackTrace();
        return null;
    }

    final XMLStreamReader xsr = tmpxsr;
    return new PeekIterator<TaggedText>() {

        @Override
        protected TaggedText internalNext() {
            ArrayList<TextSpan> openMarks = new ArrayList<>();
            StringBuilder pureTextSB = new StringBuilder();
            ArrayList<TextSpan> marks = new ArrayList<>();
            marks.add(new TextSpan(null, 0, 0));
            TaggedText tt = null;

            try {
                loop: while (xsr.hasNext()) {
                    xsr.next();
                    int event = xsr.getEventType();
                    switch (event) {
                    case XMLStreamConstants.START_ELEMENT:
                        if ("articles".equals(xsr.getLocalName())) {
                        } else if ("article".equals(xsr.getLocalName())) {
                            tt = new TaggedText();
                            for (int i = 0; i < xsr.getAttributeCount(); i++) {
                                if ("id".equals(xsr.getAttributeLocalName(i))) {
                                    tt.id = xsr.getAttributeValue(i);
                                }
                                tt.info().put(xsr.getAttributeLocalName(i), xsr.getAttributeValue(i));
                            }

                        } else if ("mark".equals(xsr.getLocalName())) {
                            TextSpan tr = new TextSpan(null, pureTextSB.length(), pureTextSB.length());
                            for (int i = 0; i < xsr.getAttributeCount(); i++) {
                                tr.info().put(xsr.getAttributeLocalName(i), xsr.getAttributeValue(i));
                            }

                            openMarks.add(tr);
                        } else if ("br".equals(xsr.getLocalName())) {
                            // TODO: how to propagate tags from the input to the output?
                        } else {
                            log.warn("ignore tag " + xsr.getLocalName());
                        }
                        break;
                    case XMLStreamConstants.END_ELEMENT:
                        if ("mark".equals(xsr.getLocalName())) {

                            // search corresponding <mark ...>
                            TextSpan tr = openMarks.remove(openMarks.size() - 1);
                            if (tr == null) {
                                log.warn("markend at " + xsr.getLocation().getCharacterOffset()
                                        + " has no corresponding mark tag");
                                break;
                            }

                            tr.end = pureTextSB.length();
                            marks.add(tr);

                        } else if ("article".equals(xsr.getLocalName())) {
                            tt.text = StringUtils.stripEnd(pureTextSB.toString().trim(), " \t\n");
                            pureTextSB = new StringBuilder();

                            tt.mentions = new ArrayList<>();
                            for (TextSpan mark : marks) {

                                String entity = mark.info().get("entity");
                                if (entity == null) {
                                    entity = mark.info().get("annotation");
                                }
                                if (entity != null) {
                                    EntityMention e = new EntityMention(tt.text, mark.start, mark.end, entity);
                                    String minMention = mark.info().get("min");
                                    String mention = e.getMention();
                                    if (minMention != null && !"".equals(minMention)) {
                                        Pattern p = Pattern.compile(Pattern.quote(minMention));
                                        Matcher m = p.matcher(mention);
                                        if (m.find()) {
                                            TextSpan min = new TextSpan(e.text, e.start + m.start(),
                                                    e.start + m.end());
                                            e.min = min;
                                            if (m.find()) {
                                                log.warn("found " + minMention + " two times in \"" + mention
                                                        + "\"");
                                            }
                                        } else {
                                            String prefix = Utility.findLongestPrefix(mention, minMention);
                                            log.warn("didn't find min mention '" + minMention + "' in text '"
                                                    + mention + "', longest prefix found: '" + prefix
                                                    + "' in article " + tt.id);
                                        }
                                    }

                                    mark.info().remove("min");
                                    mark.info().remove("entity");
                                    if (mark.info().size() > 0) {
                                        e.info().putAll(mark.info());
                                    }
                                    tt.mentions.add(e);
                                }
                            }
                            openMarks.clear();
                            marks.clear();
                            break loop;
                        }
                        break;
                    case XMLStreamConstants.CHARACTERS:
                        String toadd = xsr.getText();
                        if (pureTextSB.length() == 0) {
                            toadd = StringUtils.stripStart(toadd, " \t\n");
                        }
                        if (toadd.contains("thanks")) {
                            log.info("test");
                        }
                        pureTextSB.append(toadd);
                        break;
                    }

                }
            } catch (XMLStreamException e) {
                log.error("{}", errorMessageInfo);
                throw new RuntimeException(e);
            }
            if (tt != null && tt.mentions != null) {
                tt.mentions.sort(null);
            }
            return tt;
        }
    };
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• »