Examples of org.apache.slide.common.Uri

org.apache.slide.common.Uri
This class manages the unique identifier of an object which is manipulated by Slide. @author Remy Maucherat @version $Revision: 1.17.2.1 $

        while (parentBindings.hasMoreElements()) {
            ObjectNode.Binding parentBinding = (ObjectNode.Binding) parentBindings.nextElement();
            Element parentElm = new Element("parent", NodeProperty.NamespaceCache.DEFAULT_NAMESPACE);
            Element hrefElm = new Element("href", NodeProperty.NamespaceCache.DEFAULT_NAMESPACE);
            String parentUriStr = new UriPath(objectNode.getUri()).parent().toString();
            Uri parentUri = new Uri(uri.getToken(), uri.getNamespace(), parentUriStr);
            String uriStr;
            if (useBinding) {
                ResourceId parentResourceId = ResourceId.create(parentUri, parentBinding.getUuri());
                uriStr = getFirstMapping(parentResourceId);
            }

View Full Code Here

            String rootUriStr = uri.getScope().toString();
            if (!"/".equals(rootUriStr)) {
                rootUriStr += "/";
            }
            String currentUriStr = rootUriStr;
            Uri currentUri = new Uri(uri.getToken(), uri.getNamespace(), currentUriStr);
            ResourceId currentResourceId = ResourceId.create(currentUri, currentUriStr);
            int start = new UriPath(rootUriStr).tokens().length;
            
            for (int i = start; i < segments.length; i++) {
                // cacheResolve(currentUri, currentResourceId);
                // TODO: make it work with caching here :-(
                
                ObjectNode objectNode = currentResourceId.getStore().retrieveObject(currentResourceId);
                objectNode.setUri(currentUriStr);
                currentUriStr = uriPath.subUriPath(0, i + 1).toString();
                currentUri = new Uri(uri.getToken(), uri.getNamespace(), currentUriStr);
                String currentUuri = objectNode.getBindingUuri(segments[i]);
                if (currentUuri == null) {
                    throw new ObjectNotFoundException(currentUriStr);
                }
                currentResourceId = ResourceId.create(currentUri, currentUuri);

View Full Code Here

    private synchronized void triggerIndexers(EventCollection collection, boolean synchronous) throws IndexException {
        ContentEvent[] update = EventCollectionFilter.getChangedContents(collection);
        for ( int i = 0; i < update.length; i++ ) {
            Indexer[] indexers = getIndexers(update[i].getRevisionDescriptors(), update[i].getRevisionDescriptor(), synchronous);
            for ( int j = 0; j < indexers.length; j++ ) {
                indexers[j].updateIndex(new Uri(update[i].getNamespace(), update[i].getUri()), update[i].getRevisionDescriptor(), update[i].getRevisionContent());
            }
        }
        ContentEvent[] insert = EventCollectionFilter.getCreatedContents(collection);
        for ( int i = 0; i < insert.length; i++ ) {
            Indexer[] indexers = getIndexers(insert[i].getRevisionDescriptors(), insert[i].getRevisionDescriptor(), synchronous);
            for ( int j = 0; j < indexers.length; j++ ) {
                indexers[j].createIndex(new Uri(insert[i].getNamespace(), insert[i].getUri()), insert[i].getRevisionDescriptor(), insert[i].getRevisionContent());
            }
        }
        ContentEvent[] delete = EventCollectionFilter.getRemovedContents(collection);
        for ( int i = 0; i < delete.length; i++ ) {
            Indexer[] indexers = getIndexers(delete[i].getRevisionDescriptors(), delete[i].getRevisionDescriptor(), synchronous);
            for ( int j = 0; j < indexers.length; j++ ) {
                indexers[j].dropIndex(new Uri(delete[i].getNamespace(), delete[i].getUri()), delete[i].getRevisionDescriptor().getRevisionNumber());
            }
        }
    }

View Full Code Here

            (token, associatedObject,
             namespaceConfig.getReadRevisionContentAction());
        lockHelper.checkLock(token, associatedObject,
                             namespaceConfig.getReadRevisionContentAction());
        
        Uri objectUri = namespace.getUri(token, strUri);
        NodeRevisionContent revisionContent =
            objectUri.getStore().retrieveRevisionContent(objectUri,
                                                         revisionDescriptor);
        
        // Invoke interceptors
        invokeInterceptors(token, null, revisionDescriptor,
                           revisionContent, POST_RETRIEVE);
        
        // Fire event
        if ( ContentEvent.RETRIEVE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.RETRIEVE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptor, revisionContent));


        return revisionContent;
    }

View Full Code Here

            lockHelper.checkLock
                (token, associatedObject,
                 namespaceConfig.getCreateRevisionContentAction());
        }
        
        Uri objectUri = namespace.getUri(token, strUri);
        
        NodeRevisionDescriptors revisionDescriptors =
            new NodeRevisionDescriptors(isVersioned);
        revisionDescriptors.setUri(strUri);


        objectUri.getStore()
            .createRevisionDescriptors(objectUri, revisionDescriptors);
    }

View Full Code Here

            if (revisionDescriptor.getName() == null || revisionDescriptor.getName().length() == 0) {
                revisionDescriptor.setName(new UriPath(strUri).lastSegment());
            }
        }
        
        Uri objectUri = namespace.getUri(token, strUri);
        
        NodeRevisionDescriptors revisionDescriptors = null;
        try {
            revisionDescriptors = objectUri.getStore()
                .retrieveRevisionDescriptors(objectUri);
        } catch (RevisionDescriptorNotFoundException e) {
            // No revision descriptors. We have to create some.
            revisionDescriptors = new NodeRevisionDescriptors();
            revisionDescriptors.setUri(objectUri.toString());
            objectUri.getStore()
                .createRevisionDescriptors(objectUri, revisionDescriptors);
        }
        
        // Retrieve the latest revision from the descriptor,
        // unless there is no revisions. We generate a new revision number,
        // basing on an existing revision, if any.
        NodeRevisionNumber newRevisionNumber = null;
        if (revisionDescriptors.isVersioned()) {
            
            if (revisionDescriptors.hasRevisions()) {
                newRevisionNumber = new NodeRevisionNumber
                    (revisionDescriptors.getLatestRevision());
                revisionDescriptors
                    .addSuccessor(revisionDescriptors.getLatestRevision(),
                                  newRevisionNumber);
                revisionDescriptors
                    .setSuccessors(newRevisionNumber, new Vector());
            } else {
                newRevisionNumber = new NodeRevisionNumber();
                revisionDescriptors
                    .setSuccessors(newRevisionNumber, new Vector());
            }
            // We now set the newly created revision as the latest revison
            revisionDescriptors.setLatestRevision(newRevisionNumber);
            
            // We update the descriptor
            revisionDescriptor.setRevisionNumber(newRevisionNumber);


            // Fire event
            if ( ContentEvent.CREATE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.CREATE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptors, revisionDescriptor, revisionContent));


            // Invoke interceptors
            invokeInterceptors(token, revisionDescriptors, revisionDescriptor,
                               revisionContent, PRE_STORE);
            
            if (revisionContent != null) {
                // Storing the new revision contents
                objectUri.getStore()
                    .createRevisionContent(objectUri, revisionDescriptor,
                                           revisionContent);
            }
            // Now creating the revision desriptor in the store
            revisionDescriptor.setModificationDate(revisionDescriptor.getCreationDate());
            revisionDescriptor.setModificationUser(
                securityHelper.getPrincipal(token).getPath().lastSegment());
            objectUri.getStore()
                .createRevisionDescriptor(objectUri, revisionDescriptor);
            
        } else {
            // We don't use versioning for this object.
            // Two options :
            // - The object already has one (and only one) revision,
            //   so we update it
            // - The object dooesn't have any revisions right now, so we create
            //   the initial revision
            newRevisionNumber = new NodeRevisionNumber();
            revisionDescriptor.setRevisionNumber(newRevisionNumber);
            
            if (!revisionDescriptors.hasRevisions()) {


                // Fire event
                if ( ContentEvent.CREATE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.CREATE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptors, revisionDescriptor, revisionContent));


                // Invoke interceptors
                invokeInterceptors(token, revisionDescriptors,
                                   revisionDescriptor,
                                   revisionContent, PRE_STORE);
                
                if (revisionContent != null) {
                    // Storing the new revision contents
                    objectUri.getStore()
                        .createRevisionContent(objectUri, revisionDescriptor,
                                               revisionContent);
                }
                // Now creating the revision desriptor in the store
                revisionDescriptor.setModificationDate(revisionDescriptor.getCreationDate());
                revisionDescriptor.setModificationUser(
                    securityHelper.getPrincipal(token).getPath().lastSegment());
                objectUri.getStore()
                    .createRevisionDescriptor(objectUri, revisionDescriptor);
                
            } else {
                
                try { {
                        // merge the new received properties into the
                        // revisionDescriptor
                        
                        // We update the descriptor's properties
                        NodeRevisionDescriptor oldRevisionDescriptor =
                            objectUri.getStore()
                            .retrieveRevisionDescriptor
                            (objectUri, newRevisionNumber);
                        Enumeration newPropertiesList =
                            revisionDescriptor.enumerateProperties();
                        while (newPropertiesList.hasMoreElements()) {
                            oldRevisionDescriptor
                                .setProperty((NodeProperty) newPropertiesList
                                                 .nextElement() );
                        }
                        
                        // now use the merged revision descriptor
                        revisionDescriptor = oldRevisionDescriptor;
                    } // end of merge


                    // Fire event
                    if ( ContentEvent.CREATE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.CREATE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptors, revisionDescriptor, revisionContent));


                    // Invoke interceptors
                    invokeInterceptors(token, revisionDescriptors,
                                       revisionDescriptor,
                                       revisionContent, PRE_STORE);
                    
                    if (revisionContent != null) {
                        // Storing the new revision contents
                        try {
                            objectUri.getStore()
                                .storeRevisionContent(objectUri,
                                                      revisionDescriptor,
                                                      revisionContent);
                        } catch (RevisionNotFoundException e) {
                            objectUri.getStore()
                                .createRevisionContent(objectUri,
                                                       revisionDescriptor,
                                                       revisionContent);
                        }
                    }
                    
                    revisionDescriptor.setModificationDate(revisionDescriptor.getCreationDate());
                    revisionDescriptor.setModificationUser(
                        securityHelper.getPrincipal(token).getPath().lastSegment());
                    objectUri.getStore()
                        .storeRevisionDescriptor
                        (objectUri, revisionDescriptor);
                    
                } catch (RevisionDescriptorNotFoundException e) {
                    // Should NEVER happen.
                    // Basically, it would mean that there is no initial
                    // revision, which is incorrect since the object
                    // HAS revisions.


                    // Fire event
                    if ( ContentEvent.CREATE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.CREATE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptors, revisionDescriptor, revisionContent));


                    // Invoke interceptors
                    invokeInterceptors(token, revisionDescriptors,
                                       revisionDescriptor,
                                       revisionContent, PRE_STORE);
                    
                    revisionDescriptor.setModificationDate(revisionDescriptor.getCreationDate());
                    revisionDescriptor.setModificationUser(
                        securityHelper.getPrincipal(token).getPath().lastSegment());
                    objectUri.getStore()
                        .createRevisionDescriptor(objectUri,
                                                  revisionDescriptor);
                }
            }
            // Updating the descriptors object
            revisionDescriptors
                .setSuccessors(newRevisionNumber, new Vector());
            revisionDescriptors.setLatestRevision(newRevisionNumber);
        }
        
        // We now store the updated revision descriptors
        try {
            objectUri.getStore()
                .storeRevisionDescriptors(objectUri, revisionDescriptors);
        } catch (RevisionDescriptorNotFoundException e) {
            // Problem ...
            e.printStackTrace();
        }

View Full Code Here

        BranchNotFoundException, VetoException {
        
        // Check parent exists and is not lock-null
        checkParentExists(strUri, token);
        
        Uri objectUri = namespace.getUri(token, strUri);
        
        NodeRevisionDescriptors revisionDescriptors = objectUri.getStore()
            .retrieveRevisionDescriptors(objectUri);
        
        if( branch != null ) {
            // Retrieving latest revision numbers
            NodeRevisionNumber branchLatestRevisionNumber =

View Full Code Here

            (token, associatedObject,
             namespaceConfig.getCreateRevisionContentAction());
        lockHelper.checkLock(token, associatedObject,
                             namespaceConfig.getCreateRevisionContentAction());
        
        Uri objectUri = namespace.getUri(token, strUri);
        
        // Retrieve the revision table
        NodeRevisionDescriptors revisionDescriptors =
            objectUri.getStore()
            .retrieveRevisionDescriptors(objectUri);
        
        if (!revisionDescriptors.isVersioned()) {
            // Invalid function call : we try to create a revision, but the
            // descriptors won't allow it
            throw new NodeNotVersionedException(strUri);
        }
        
        // Retrieving the revision on which the new branch is based.
        NodeRevisionDescriptor basedOnRevisionDescriptor =
            objectUri.getStore().retrieveRevisionDescriptor
            (objectUri, basedOnRevisionNumber);
        NodeRevisionContent basedOnRevisionContent = null;
        try {
            basedOnRevisionContent =
                objectUri.getStore().retrieveRevisionContent
                (objectUri,
                 basedOnRevisionDescriptor);
        } catch (RevisionNotFoundException e) {
        }
        
        // Create a revision number suited for the new branch
        NodeRevisionNumber branchedRevisionNumber =
            new NodeRevisionNumber(basedOnRevisionNumber, true);
        
        basedOnRevisionDescriptor.setRevisionNumber(branchedRevisionNumber);
        basedOnRevisionDescriptor.setBranchName(branchName);
        
        revisionDescriptors.setUri(strUri);
        revisionDescriptors.setLatestRevision
            (branchName, branchedRevisionNumber);
        revisionDescriptors.addSuccessor
            (basedOnRevisionNumber, branchedRevisionNumber);
        
        // Fire event
        if ( ContentEvent.FORK.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.FORK, new ContentEvent(this, token, namespace, strUri, revisionDescriptors));


        // Invoke interceptors
        invokeInterceptors(token, revisionDescriptors,
                           basedOnRevisionDescriptor,
                           basedOnRevisionContent, PRE_STORE);
        
        // Storing back everything
        // TODO: setModificationDate
        //       clone of NRD required??
        if (basedOnRevisionContent != null) {
            objectUri.getStore().createRevisionContent
                (objectUri, basedOnRevisionDescriptor, basedOnRevisionContent);
        }
        objectUri.getStore().createRevisionDescriptor
            (objectUri, basedOnRevisionDescriptor);
        objectUri.getStore().storeRevisionDescriptors
            (objectUri, revisionDescriptors);
        
        // Invoke interceptors
        invokeInterceptors(token, revisionDescriptors,
                           basedOnRevisionDescriptor,

View Full Code Here

        lockHelper.checkLock(token, associatedObject,
                             namespaceConfig.getCreateRevisionContentAction());
        
        setDefaultProperties(associatedObject, newRevisionDescriptor);
        
        Uri objectUri = namespace.getUri(token, strUri);
        
        // Retrieve the revision table
        NodeRevisionDescriptors revisionDescriptors =
            objectUri.getStore().retrieveRevisionDescriptors(objectUri);
        
        if (!revisionDescriptors.isVersioned()) {
            // Invalid function call : we try to create a revision, but the
            // descriptors won't allow it
            throw new NodeNotVersionedException(strUri);
        }
        
        // Retrieving latest revision numbers
        NodeRevisionNumber mainBranchLatestRevisionNumber =
            revisionDescriptors.getLatestRevision(mainBranch);
        NodeRevisionNumber branchLatestRevisionNumber =
            revisionDescriptors.getLatestRevision(branch);
        
        if (mainBranchLatestRevisionNumber == null) {
            throw new BranchNotFoundException(strUri, mainBranch);
        }
        if (branchLatestRevisionNumber == null) {
            throw new BranchNotFoundException(strUri, branch);
        }
        
        NodeRevisionNumber newRevisionNumber =
            new NodeRevisionNumber(mainBranchLatestRevisionNumber);
        
        newRevisionDescriptor.setRevisionNumber(newRevisionNumber);
        newRevisionDescriptor.setBranchName(branch);
        
        revisionDescriptors.addSuccessor
            (mainBranchLatestRevisionNumber, newRevisionNumber);
        revisionDescriptors.addSuccessor
            (branchLatestRevisionNumber, newRevisionNumber);
        revisionDescriptors.setLatestRevision(mainBranch, newRevisionNumber);
        
        // Fire event
        if ( ContentEvent.MERGE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.MERGE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptors, newRevisionDescriptor, revisionContent));


        // Invoke interceptors
        invokeInterceptors(token, revisionDescriptors, newRevisionDescriptor,
                           revisionContent, PRE_STORE);
        
        // Storing back everything
        if (revisionContent != null) {
            objectUri.getStore().createRevisionContent
                (objectUri, newRevisionDescriptor, revisionContent);
        }
        newRevisionDescriptor.setModificationDate(newRevisionDescriptor.getCreationDate());
        newRevisionDescriptor.setModificationUser(
            securityHelper.getPrincipal(token).getPath().lastSegment());
        objectUri.getStore().createRevisionDescriptor
            (objectUri, newRevisionDescriptor);
        objectUri.getStore().storeRevisionDescriptors
            (objectUri, revisionDescriptors);
        
        // Invoke interceptors
        invokeInterceptors(token, revisionDescriptors, newRevisionDescriptor,
                           revisionContent, POST_STORE);

View Full Code Here

        lockHelper.checkLock(token, associatedObject,
                             namespaceConfig.getModifyRevisionContentAction());
        
        setDefaultProperties(associatedObject, revisionDescriptor);
        
        Uri objectUri = namespace.getUri(token, strUri);
        
        // Retrieve the revision table
        NodeRevisionDescriptors revisionDescriptors =
            objectUri.getStore().retrieveRevisionDescriptors(objectUri);


        // Fire event
        if ( revisionDescriptor.getRevisionNumber() != NodeRevisionNumber.HIDDEN_0_0 && ContentEvent.STORE.isEnabled() ) EventDispatcher.getInstance().fireVetoableEvent(ContentEvent.STORE, new ContentEvent(this, token, namespace, objectUri.toString(), revisionDescriptors, revisionDescriptor, revisionContent));


        // Invoke interceptors
        invokeInterceptors(token, revisionDescriptors, revisionDescriptor,
                           revisionContent, PRE_STORE);
        
        if (revisionContent != null) {
            try {
                // Removed retrieveContent call [pnever, 25-APR-2003].
                // Reasons:
                // - it is not necessary to check existence because storeRevisionContent also throws RevisionNotFoundException
                // - it is harmful for filesystem-based stores, as the input streams created by retrieveRevisionContent never are closed
                // Simple scenario:
                // Use the FileContentStore, create a file, update it and then try to delete it.
                // It will not be deleted from the filesystem.
                //
                //                objectUri.getStore().retrieveRevisionContent
                //                    (objectUri, revisionDescriptor);
                objectUri.getStore().storeRevisionContent
                    (objectUri, revisionDescriptor, revisionContent);
            } catch (RevisionNotFoundException e) {
                try {
                    objectUri.getStore().createRevisionContent
                        (objectUri, revisionDescriptor, revisionContent);
                } catch (RevisionAlreadyExistException ex) {
                    // Should never happen
                    ex.printStackTrace();
                }
            }
        }
        revisionDescriptor.setModificationDate(new Date());
        revisionDescriptor.setModificationUser(
            securityHelper.getPrincipal(token).getPath().lastSegment());
        objectUri.getStore().storeRevisionDescriptor
            (objectUri, revisionDescriptor);
        
        // Invoke interceptors
        invokeInterceptors(token, revisionDescriptors, revisionDescriptor,
                           revisionContent, POST_STORE);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.slide.common.Uri

org.apache.slide.cluster.ClusterCacheRefresher

org.apache.slide.content.ContentImpl

org.apache.slide.event.ContentModifiedNotifier

org.apache.slide.lock.LockImpl

org.apache.slide.macro.MacroImpl

org.apache.slide.macro.MacroPropertyUpdater

org.apache.slide.search.basic.BasicQuery

org.apache.slide.search.basic.BasicQueryEnvelope

org.apache.slide.search.basic.BasicQueryImpl

org.apache.slide.search.basic.BasicSearchLanguage

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.