Examples of org.apache.jackrabbit.oak.spi.state.NodeState

Package org.apache.jackrabbit.oak.spi.state

Examples of org.apache.jackrabbit.oak.spi.state.NodeState

org.apache.jackrabbit.oak.spi.state.NodeState
A node in a content tree consists of child nodes and properties, each of which evolves through different states during its lifecycle. This interface represents a specific, immutable state of a node. The state consists of an unordered set of name -> item mappings, where each item is either a property or a child node.
Depending on context, a NodeState instance can be interpreted as representing the state of just that node, of the subtree starting at that node, or of an entire tree in case it's a root node.
The crucial difference between this interface and the similarly named class in Jackrabbit 2.x is that this interface represents a specific, immutable state of a node, whereas the Jackrabbit 2.x class represented the current state of a node.
Immutability and thread-safety

As mentioned above, all node and property states are always immutable. Thus repeating a method call is always guaranteed to produce the same result as before unless some internal error occurs (see below). This immutability only applies to a specific state instance. Different states of a node can obviously be different, and in some cases even different instances of the same state may behave slightly differently. For example due to performance optimization or other similar changes the iteration order of properties or child nodes may be different for two instances of the same state.
In addition to being immutable, a specific state instance guaranteed to be fully thread-safe. Possible caching or other internal changes need to be properly synchronized so that any number of concurrent clients can safely access a state instance.
Persistence and error-handling

A node state can be (and often is) backed by local files or network resources. All IO operations or related concerns like caching should be handled transparently below this interface. Potential IO problems and recovery attempts like retrying a timed-out network access need to be handled below this interface, and only hard errors should be thrown up as {@link RuntimeException unchecked exceptions} that higher level codeis not expected to be able to recover from.
Since this interface exposes no higher level constructs like locking, node types or even path parsing, there's no way for content access to fail because of such concerns. Such functionality and related checked exceptions or other control flow constructs should be implemented on a higher level above this interface. On the other hand read access controls can be implemented below this interface, in which case some content that would otherwise be accessible might not show up through such an implementation.
Existence and iterability of node states

The {@link #getChildNode(String)} method is special in that itnever returns a {@code null} value, even if the named childnode does not exist. Instead a client should use the {@link #exists()}method on the returned child state to check whether that node exists. The purpose of this separation of concerns is to allow an implementation to lazily load content only when it's actually read instead of just traversed. It also simplifies client code by avoiding the need for many {@code null} checks when traversing paths.
The iterability of a node is a related concept to the above-mentioned existence. A node state is iterable if it is included in the return values of the {@link #getChildNodeCount(long)}, {@link #getChildNodeNames()} and {@link #getChildNodeEntries()} methods.An iterable node is guaranteed to exist, though not all existing nodes are necessarily iterable.
Furthermore, a non-existing node is guaranteed to contain no properties or iterable child nodes. It can, however contain non-iterable children. Such scenarios are typically the result of access control restrictions.
Decoration and virtual content

Not all content exposed by this interface needs to be backed by actual persisted data. An implementation may want to provide derived data, like for example the aggregate size of the entire subtree as an extra virtual property. A virtualization, sharding or caching layer could provide a composite view over multiple underlying trees. Or a an access control layer could decide to hide certain content based on specific rules. All such features need to be implemented according to the API contract of this interface. A separate higher level interface needs to be used if an implementation can't for example guarantee immutability of exposed content as discussed above.
Equality and hash codes

Two node states are considered equal if and only if their existence, properties and iterable child nodes match, regardless of ordering. The {@link Object#equals(Object)} method needs to be implemented so that itcomplies with this definition. And while node states are not meant for use as hash keys, the {@link Object#hashCode()} method should still beimplemented according to this equality contract.

                        return false;
                    }
                }
            }
        } else if (afterChildName != Template.MANY_CHILD_NODES) {
            NodeState afterNode = afterTemplate.getChildNode(
                    afterChildName, afterSegment, afterId);
            NodeState beforeNode = beforeTemplate.getChildNode(
                    afterChildName, beforeSegment, beforeId);
            if (!beforeNode.exists()) {
                if (!diff.childNodeAdded(afterChildName, afterNode)) {
                    return false;
                }
            } else if (!fastEquals(afterNode, beforeNode)) {
                if (!diff.childNodeChanged(
                        afterChildName, beforeNode, afterNode)) {
                    return false;
                }
            }
            if (beforeChildName == Template.MANY_CHILD_NODES
                    || (beforeChildName != Template.ZERO_CHILD_NODES
                        && !beforeNode.exists())) {
                for (ChildNodeEntry entry :
                    beforeTemplate.getChildNodeEntries(beforeSegment, beforeId)) {
                    if (!afterChildName.equals(entry.getName())) {
                        if (!diff.childNodeDeleted(
                                entry.getName(), entry.getNodeState())) {
                            return false;
                        }
                    }
                }
            }
        } else if (beforeChildName == Template.ZERO_CHILD_NODES) {
            for (ChildNodeEntry entry
                    : afterTemplate.getChildNodeEntries(afterSegment, afterId)) {
                if (!diff.childNodeAdded(
                        entry.getName(), entry.getNodeState())) {
                    return false;
                }
            }
        } else if (beforeChildName != Template.MANY_CHILD_NODES) {
            for (ChildNodeEntry entry : afterTemplate.getChildNodeEntries(afterSegment, afterId)) {
                String childName = entry.getName();
                NodeState afterChild = entry.getNodeState();
                if (beforeChildName.equals(childName)) {
                    NodeState beforeChild = beforeTemplate.getChildNode(
                            beforeChildName, beforeSegment, beforeId);
                    if (beforeChild.exists()) {
                        if (!fastEquals(afterChild, beforeChild)
                                && !diff.childNodeChanged(
                                        childName, beforeChild, afterChild)) {
                            return false;
                        }

View Full Code Here

        if (isRoot() || !exists() || newParent.hasChildNode(newName)) {
            return false;
        } else {
            if (newParent.exists()) {
                annotateSourcePath();
                NodeState nodeState = getNodeState();
                newParent.setChildNode(newName, nodeState);
                remove();
                return true;
            } else {
                return false;

View Full Code Here

            return head.getValue(Type.STRING);
        }
    }


    private boolean isTransientlyAdded(String path) {
        NodeState node = rootBuilder.getBaseState();
        for (String name : PathUtils.elements(path)) {
            node = node.getChildNode(name);
        }
        return !node.exists();
    }

View Full Code Here

     * @param root root node state
     * @return read-only node type manager
     */
    @Nonnull
    public static ReadOnlyNodeTypeManager getInstance(NodeState root) {
        NodeState typesNode = root;
        for (String name : PathUtils.elements(NODE_TYPES_PATH)) {
            typesNode = typesNode.getChildNode(name);
        }


        final Tree typesTree = new ImmutableTree(typesNode);
        return new ReadOnlyNodeTypeManager() {
            @Override

View Full Code Here

                    readCount++;
                    if (readCount % 1000 == 0) {
                        LOG.warn("Traversed " + readCount + " nodes using index " + indexName + " with filter " + filter);
                    }


                    NodeState node = entry.getNodeState();


                    String name = entry.getName();
                    if (NodeStateUtils.isHidden(name)) {
                        continue;
                    }
                    currentPath = PathUtils.concat(parentPath, name);


                    nodeIterators.addLast(node.getChildNodeEntries().iterator());
                    parentPath = currentPath;


                    if (node.getBoolean("match")) {
                        return;
                    }
                    
                } else {
                    nodeIterators.removeLast();

View Full Code Here

            undefinedType = UNDEFINED.toString();
        }


        // Find matching named property definition
        for (NodeState type : types) {
            NodeState definitions = type
                    .getChildNode(REP_NAMED_PROPERTY_DEFINITIONS)
                    .getChildNode(escapedName);


            NodeState definition = definitions.getChildNode(definedType);
            if (definition.exists()) {
                return definition;
            }


            definition = definitions.getChildNode(undefinedType);
            if (definition.exists()) {
                return definition;
            }


            // OAK-822: a mandatory definition always overrides residual ones
            // TODO: unnecessary if the OAK-713 fallback wasn't needed below
            for (ChildNodeEntry entry : definitions.getChildNodeEntries()) {
                definition = entry.getNodeState();
                if (definition.getBoolean(JCR_MANDATORY)) {
                    return definition;
                }
            }


// TODO: Fall back to residual definitions until we have consensus on OAK-713
//          throw new ConstraintViolationException(
//                "No matching definition found for property " + propertyName);
        }


        // Find matching residual property definition
        for (NodeState type : types) {
            NodeState residual =
                    type.getChildNode(REP_RESIDUAL_PROPERTY_DEFINITIONS);
            NodeState definition = residual.getChildNode(definedType);
            if (!definition.exists()) {
                definition = residual.getChildNode(undefinedType);
            }
            if (definition.exists()) {
                return definition;
            }
        }


        return null;

View Full Code Here

        boolean sns = !name.equals(nameWithIndex);
        Set<String> typeNames = effective.getTypeNames();


        // Find matching named child node definition
        for (NodeState type : types) {
            NodeState definitions = type
                    .getChildNode(REP_NAMED_CHILD_NODE_DEFINITIONS)
                    .getChildNode(name);


            for (String typeName : typeNames) {
                NodeState definition = definitions.getChildNode(typeName);
                if (definition.exists() && snsMatch(sns, definition)) {
                    return true;
                }
            }


            // OAK-822: a mandatory definition always overrides alternatives
            // TODO: unnecessary if the OAK-713 fallback wasn't needed below
            for (ChildNodeEntry entry : definitions.getChildNodeEntries()) {
                NodeState definition = entry.getNodeState();
                if (definition.getBoolean(JCR_MANDATORY)) {
                    return false;
                }
            }


// TODO: Fall back to residual definitions until we have consensus on OAK-713
//          throw new ConstraintViolationException(
//                  "Incorrect node type of child node " + nodeName);
        }


        // Find matching residual child node definition
        for (NodeState type : types) {
            NodeState residual =
                    type.getChildNode(REP_RESIDUAL_CHILD_NODE_DEFINITIONS);
            for (String typeName : typeNames) {
                NodeState definition = residual.getChildNode(typeName);
                if (definition.exists() && snsMatch(sns, definition)) {
                    return true;
                }
            }
        }

View Full Code Here

        @Override
        public Head update() {
            long rootRevision = rootHead().revision;
            if (revision != rootRevision) {
                // root revision changed: recursively re-get state from parent
                NodeState parentState = parent.head().getCurrentNodeState();
                NodeState newState = parentState.getChildNode(name);
                if (newState instanceof MutableNodeState) {
                    // transition state to ConnectedHead
                    return new ConnectedHead((MutableNodeState) newState);
                } else {
                    // update to match the latest revision

View Full Code Here

    String getDefaultType(String nameWithIndex) {
        String name = dropIndexFromName(nameWithIndex);
        boolean sns = !name.equals(nameWithIndex);


        for (NodeState type : types) {
            NodeState named = type
                    .getChildNode(REP_NAMED_CHILD_NODE_DEFINITIONS)
                    .getChildNode(name);
            NodeState residual = type
                    .getChildNode(REP_RESIDUAL_CHILD_NODE_DEFINITIONS);


            for (ChildNodeEntry entry : concat(
                    named.getChildNodeEntries(),
                    residual.getChildNodeEntries())) {
                NodeState definition = entry.getNodeState();
                String defaultType = definition.getName(JCR_DEFAULTPRIMARYTYPE);
                if (defaultType != null && snsMatch(sns, definition)) {
                    return defaultType;
                }
            }
        }

View Full Code Here

    }


    @Override
    public Iterable<String> query(final Filter filter, final String indexName, 
            final NodeState indexMeta, final Iterable<String> values) {
        final NodeState index = indexMeta.getChildNode(INDEX_CONTENT_NODE_NAME);
        return new Iterable<String>() {
            @Override
            public Iterator<String> iterator() {
                if (values == null) {
                    return new Iterator<String>() {
                        
                        Iterator<? extends ChildNodeEntry> it = index.getChildNodeEntries().iterator();


                        @Override
                        public boolean hasNext() {
                            return it.hasNext();
                        }


                        @Override
                        public String next() {
                            PropertyState s = it.next().getNodeState().getProperty("entry");
                            return s.getValue(Type.STRING, 0);
                        }


                        @Override
                        public void remove() {
                            it.remove();
                        }
                        
                    };
                }
                ArrayList<String> list = new ArrayList<String>();
                for (String p : values) {
                    NodeState key = index.getChildNode(p);
                    if (key.exists()) {
                        // we have an entry for this value, so use it
                        PropertyState s = key.getProperty("entry");
                        String v = s.getValue(Type.STRING, 0);
                        list.add(v);
                    }
                }
                return list.iterator();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.jackrabbit.oak.spi.state.NodeState

org.apache.jackrabbit.oak.console.ConsoleSession

org.apache.jackrabbit.oak.core.AbstractRoot

org.apache.jackrabbit.oak.core.ContentRepositoryImpl

org.apache.jackrabbit.oak.core.ReadOnlyTree

org.apache.jackrabbit.oak.core.RootImpl

org.apache.jackrabbit.oak.core.SecureNodeBuilder

org.apache.jackrabbit.oak.core.SecureNodeState

org.apache.jackrabbit.oak.core.TreeImpl

org.apache.jackrabbit.oak.explorer.NodeStoreTree

org.apache.jackrabbit.oak.explorer.NodeStoreTree$NamePathModel

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.

Examples of org.apache.jackrabbit.oak.spi.state.NodeState

Immutability and thread-safety

Persistence and error-handling

Existence and iterability of node states

Decoration and virtual content

Equality and hash codes

Related Classes of org.apache.jackrabbit.oak.spi.state.NodeState