Package org.apache.jackrabbit.oak.plugins.memory

Class ModifiedNodeState

  • All Implemented Interfaces:
    NodeState
    public class ModifiedNodeState
extends AbstractNodeState
    Immutable snapshot of a mutable node state.

    • Method Detail

      • squeeze

        public static NodeState squeeze​(NodeState state)
        "Squeezes" ModifiedNodeState instances into equivalent MemoryNodeStates. Other kinds of states are returned as-is.

      • getBaseState

        @NotNull
public @NotNull NodeState getBaseState()

      • builder

        @NotNull
public @NotNull NodeBuilder builder()
        Description copied from interface: NodeState
        Returns a builder for constructing a new node state based on this state, i.e. starting with all the properties and child nodes of this state.
        Returns:
        node builder based on this state

      • exists

        public boolean exists()
        Description copied from interface: NodeState
        Checks whether this node exists. See the above discussion about the existence of node states.
        Returns:
        true if this node exists, false if not

      • hasProperty

        public boolean hasProperty​(@NotNull
                           @NotNull java.lang.String name)
        Description copied from interface: NodeState
        Checks whether the named property exists. The implementation is equivalent to getProperty(name) != null, but may be optimized to avoid having to load the property value.
        Specified by:
        hasProperty in interface NodeState
        Overrides:
        hasProperty in class AbstractNodeState
        Parameters:
        name - property name
        Returns:
        true if the named property exists, false otherwise

      • getProperty

        public PropertyState getProperty​(@NotNull
                                 @NotNull java.lang.String name)
        Description copied from interface: NodeState
        Returns the named property, or null if no such property exists.
        Specified by:
        getProperty in interface NodeState
        Overrides:
        getProperty in class AbstractNodeState
        Parameters:
        name - name of the property to return
        Returns:
        named property, or null if not found

      • getProperties

        @NotNull
public @NotNull java.lang.Iterable<? extends PropertyState> getProperties()
        Description copied from interface: NodeState
        Returns an iterable of the properties of this node. Multiple iterations are guaranteed to return the properties in the same order, but the specific order used is implementation-dependent and may change across different states of the same node.
        Returns:
        properties in some stable order

      • getChildNodeCount

        public long getChildNodeCount​(long max)
        Description copied from interface: NodeState
        Returns the number of iterable child nodes of this node.

        If an implementation knows the exact value, it returns it (even if the value is higher than max). If the implementation does not know the exact value, and the child node count is higher than max, it may return Long.MAX_VALUE. The cost of the operation is at most O(max).

        Specified by:
        getChildNodeCount in interface NodeState
        Overrides:
        getChildNodeCount in class AbstractNodeState
        Parameters:
        max - the maximum number of entries to traverse
        Returns:
        number of iterable child nodes

      • hasChildNode

        public boolean hasChildNode​(@NotNull
                            @NotNull java.lang.String name)
        Description copied from interface: NodeState
        Checks whether the named child node exists. The implementation is equivalent to getChildNode(name).exists(), except that passing an invalid name as argument will result in a false return value instead of an IllegalArgumentException.
        Parameters:
        name - name of the child node
        Returns:
        true if the named child node exists, false otherwise

      • getChildNode

        @NotNull
public @NotNull NodeState getChildNode​(@NotNull
                                       @NotNull java.lang.String name)
        Description copied from interface: NodeState
        Returns the named, possibly non-existent, child node. Use the NodeState.exists() method on the returned child node to determine whether the node exists or not.
        Parameters:
        name - name of the child node to return
        Returns:
        named child node

      • getChildNodeEntries

        @NotNull
public @NotNull java.lang.Iterable<? extends ChildNodeEntry> getChildNodeEntries()
        Description copied from interface: NodeState
        Returns the iterable child node entries of this instance. Multiple iterations are guaranteed to return the child nodes in the same order, but the specific order used is implementation dependent and may change across different states of the same node.

        Note on cost and performance: while it is possible to iterate over all child NodeStates with the two methods NodeState.getChildNodeNames() and NodeState.getChildNode(String), this method is considered more efficient because an implementation can potentially perform the retrieval of the name and NodeState in one call. This results in O(n) vs. O(n log n) when iterating over the child node names and then look up the NodeState by name.

        Returns:
        child node entries in some stable order

      • compareAgainstBaseState

        public boolean compareAgainstBaseState​(NodeState base,
                                       NodeStateDiff diff)
        Since we keep track of an explicit base node state for a ModifiedNodeState instance, we can do this in two steps: first compare all the modified properties and child nodes to those of the given base state, and then compare the base states to each other, ignoring all changed properties and child nodes that were already covered earlier.
        Specified by:
        compareAgainstBaseState in interface NodeState
        Overrides:
        compareAgainstBaseState in class AbstractNodeState
        Parameters:
        base - base state
        diff - handler of node state differences
        Returns:
        true if the full diff was performed, or false if it was aborted as requested by the handler (see the NodeStateDiff contract for more details)