Package org.modeshape.jcr.cache

Examples of org.modeshape.jcr.cache.NodeKey


     * @param childNodeDef the child node definition to be projected
     */
    private void store( MutableCachedNode nodeTypeNode,
                        JcrNodeDefinition childNodeDef ) {
        // Find an existing node for this property definition ...
        final NodeKey key = childNodeDef.key();
        final Name name = childNodeDef.getInternalName();
        MutableCachedNode nodeDefnNode = null;
        if (!nodeTypeNode.isNew()) {
            if (nodeTypeNode.getChildReferences(system).hasChild(key)) {
                // The node already exists ...
View Full Code Here


    public void remove( IndexDefinition indexDefn ) {
        assert indexDefn != null;
        assert system != null;
        MutableCachedNode indexes = mutableIndexesNode();
        final NodeKey providerKey = nodeKey(indexes.getKey(), indexDefn.getProviderName());
        if (indexes.getChildReferences(system).hasChild(providerKey)) {
            // Find the provider node ...
            MutableCachedNode providerNode = system.mutable(providerKey);

            // And remove the index defn from the provider ...
            final NodeKey key = nodeKey(providerNode.getKey(), indexDefn);
            providerNode.removeChild(system, key);
            system.destroy(key);

            // If there are no more children under the provider, remove it, too...
            if (providerNode.getChildReferences(system).isEmpty()) {
View Full Code Here

        assert indexes != null;
        assert indexDefn.getName() != null;

        // First find or create the provider node ...
        MutableCachedNode providerNode = null;
        final NodeKey providerKey = nodeKey(indexes.getKey(), indexDefn.getProviderName());
        if (indexes.getChildReferences(system).hasChild(providerKey)) {
            // The node already exists ...
            providerNode = system.mutable(providerKey);
        } else {
            // Create the new provider node ...
            Property primaryType = propertyFactory.create(JcrLexicon.PRIMARY_TYPE, ModeShapeLexicon.INDEX_PROVIDER);
            Name providerName = names.create(indexDefn.getProviderName());
            providerNode = indexes.createChild(system, providerKey, providerName, primaryType);
        }
        assert providerNode != null;

        Name name = names.create(indexDefn.getName());
        final NodeKey key = nodeKey(indexes.getKey(), indexDefn);
        MutableCachedNode indexNode = null;
        Set<NodeKey> existingChildKeys = null;

        if (providerNode.getChildReferences(system).hasChild(key)) {
            // The node already exists ...
            if (!updateExisting) return;
            indexNode = system.mutable(key);

            // We'll need to delete any existing column that isn't there anymore ...
            existingChildKeys = new HashSet<NodeKey>();
            for (ChildReference childRef : indexNode.getChildReferences(system)) {
                existingChildKeys.add(childRef.getKey());
            }
        }

        // Define the properties for this index definition ...
        List<Property> properties = new ArrayList<Property>();
        // Add the extended properties first, in case the standard ones overwrite them ...
        for (Map.Entry<String, Object> entry : indexDefn.getIndexProperties().entrySet()) {
            Property prop = createProperty(entry.getKey(), entry.getValue());
            if (prop != null) properties.add(prop);
        }

        // Now do the standard properties ...
        properties.add(propertyFactory.create(JcrLexicon.PRIMARY_TYPE, ModeShapeLexicon.INDEX));
        properties.add(propertyFactory.create(JcrLexicon.DESCRIPTION, indexDefn.getDescription()));
        properties.add(propertyFactory.create(ModeShapeLexicon.KIND, indexDefn.getKind().name()));
        properties.add(propertyFactory.create(ModeShapeLexicon.NODE_TYPE_NAME, indexDefn.getNodeTypeName()));
        properties.add(propertyFactory.create(ModeShapeLexicon.SYNCHRONOUS, indexDefn.isSynchronous()));

        // Now make or adjust the node for the index definition ...
        if (indexNode != null) {
            // Update the properties ...
            indexNode.setProperties(system, properties);
        } else {
            // We have to create the index definition node ...
            indexNode = providerNode.createChild(system, key, name, properties);
        }

        // And the column definitions ...
        for (IndexColumnDefinition columnDefn : indexDefn) {
            NodeKey columnDefnKey = store(indexNode, columnDefn);
            if (existingChildKeys != null) existingChildKeys.remove(columnDefnKey);
        }

        // Remove any column defns that weren't represented in the index definition ...
        if (existingChildKeys != null && !existingChildKeys.isEmpty()) {
View Full Code Here

    }

    private NodeKey store( MutableCachedNode indexDefn,
                           IndexColumnDefinition columnDefn ) {
        // Find an existing node for this column definition ...
        final NodeKey key = nodeKey(indexDefn.getKey(), columnDefn);
        final Name name = ModeShapeLexicon.INDEX_COLUMN;
        MutableCachedNode columnDefnNode = null;
        if (!indexDefn.isNew()) {
            if (indexDefn.getChildReferences(system).hasChild(key)) {
                // The node already exists ...
View Full Code Here

                system.destroy(ref.getKey());
                continue;
            }

            // Look for an existing namespace node that uses the same URI ...
            NodeKey key = keyForNamespaceUri(newUri);
            CachedNode existingNode = system.getNode(key);
            if (existingNode != null) {
                // Get the prefix for the existing namespace node ...
                Segment segment = existingNode.getSegment(system);
                String existingPrefix = prefixFor(segment);
View Full Code Here

        return removedPrefixes;
    }

    public String readNamespacePrefix( String namespaceUri,
                                       boolean generateIfMissing ) {
        NodeKey key = keyForNamespaceUri(namespaceUri);
        CachedNode nsNode = system.getNode(key);
        if (nsNode != null) {
            // There's an existing node, so just read the prefix (e.g., the name) ...
            Segment segment = nsNode.getSegment(system);
            return prefixFor(segment);
View Full Code Here

        return prefixFor(newNsNode.getSegment(system));
    }

    protected boolean unregisterNamespace( String namespaceUri ) {
        MutableCachedNode namespaces = mutableNamespacesNode();
        NodeKey key = keyForNamespaceUri(namespaceUri);
        CachedNode nsNode = system.getNode(key);
        if (nsNode != null) {
            namespaces.removeChild(system, key);
            system.destroy(key);
            return true;
View Full Code Here

    }

    protected void unregisterNodeTypes( JcrNodeType... nodeTypes ) {
        MutableCachedNode nodeTypesNode = mutableNodeTypesNode();
        for (JcrNodeType nodeType : nodeTypes) {
            NodeKey nodeTypeKey = nodeType.key();
            nodeTypesNode.removeChild(system, nodeTypeKey);
            system.destroy(nodeTypeKey);
        }
    }
View Full Code Here

        locksNode.createChild(system, lock.getLockKey(), name, properties);
    }

    void removeLock( ModeShapeLock lock ) {
        MutableCachedNode locksNode = mutableLocksNode();
        NodeKey lockKey = lock.getLockKey();
        locksNode.removeChild(system, lockKey);
        system.destroy(lockKey);
    }
View Full Code Here

                // Look up the child node ...
                node = system.getNode(ref);
            } else {
                // Create the intermediate node ...
                MutableCachedNode mutableNode = system.mutable(node.getKey());
                NodeKey key = systemKey().withRandomId();
                if (primaryType == null) {
                    primaryType = propertyFactory.create(JcrLexicon.PRIMARY_TYPE, ModeShapeLexicon.VERSION_HISTORY_FOLDER);
                }
                mutable = mutableNode.createChild(system, key, segment.getName(), primaryType);
                node = mutable;
            }
        }

        // See if the version history exists ...
        MutableCachedNode historyParent = mutable != null ? mutable : system.mutable(node.getKey());

        // Now create the version history node itself ...
        List<Property> historyProps = new ArrayList<Property>();
        historyProps.add(propertyFactory.create(JcrLexicon.PRIMARY_TYPE, JcrNtLexicon.VERSION_HISTORY));
        historyProps.add(propertyFactory.create(JcrLexicon.VERSIONABLE_UUID, versionableNodeKey.getIdentifier()));
        historyProps.add(propertyFactory.create(JcrLexicon.UUID, versionHistoryKey.getIdentifier()));
        if (originalVersionKey != null) {
            // the tck expects this to be a reference, so that getNode works on it
            historyProps.add(propertyFactory.create(JcrLexicon.COPIED_FROM, org.modeshape.jcr.value.PropertyType.WEAKREFERENCE,
                                                    referenceFactory.create(originalVersionKey, true)));
        }
        Name historyName = versionHistoryPath.getLastSegment().getName();
        MutableCachedNode history = historyParent.createChild(system, versionHistoryKey, historyName, historyProps);

        // Now create the 'nt:versionLabels' child node ...
        Property labelProp = propertyFactory.create(JcrLexicon.PRIMARY_TYPE, JcrNtLexicon.VERSION_LABELS);
        MutableCachedNode labels = history.createChild(system, null, JcrLexicon.VERSION_LABELS, labelProp);
        assert labels != null;

        // And create the 'nt:rootVersion' child node ...
        NodeKey rootVersionKey = versionKey != null ? versionKey : systemKey().withRandomId();
        List<Property> rootProps = new ArrayList<Property>();
        rootProps.add(propertyFactory.create(JcrLexicon.PRIMARY_TYPE, JcrNtLexicon.VERSION));
        rootProps.add(propertyFactory.create(JcrLexicon.CREATED, now));
        rootProps.add(propertyFactory.create(JcrLexicon.UUID, rootVersionKey.getIdentifier()));
        MutableCachedNode rootVersion = history.createChild(system, rootVersionKey, JcrLexicon.ROOT_VERSION, rootProps);

        // And create the 'nt:rootVersion/nt:frozenNode' child node ...
        NodeKey frozenNodeKey = rootVersion.getKey().withRandomId();

        List<Property> frozenProps = new ArrayList<Property>();
        frozenProps.add(propertyFactory.create(JcrLexicon.PRIMARY_TYPE, JcrNtLexicon.FROZEN_NODE));
        frozenProps.add(propertyFactory.create(JcrLexicon.FROZEN_UUID, versionableNodeKey.getIdentifier()));
        frozenProps.add(propertyFactory.create(JcrLexicon.FROZEN_PRIMARY_TYPE, primaryTypeName));
View Full Code Here

TOP

Related Classes of org.modeshape.jcr.cache.NodeKey

Copyright © 2018 www.massapicom. All rights reserved.
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.