All Classes and Interfaces
Class
Description
Abstract base class for
Blob implementations.Abstract base class for
ChildNodeEntry implementations.Abstract base class for
NodeState implementations.Abstract base class for
PropertyState implementations.AbstractRebaseDiff serves as base for rebase implementations.A node state diff handler that applies all reported changes
as-is to the given node builder.
This
Blob implementations is based on an array of bytes.An observer that uses a change queue and a background thread to forward
content changes to another observer.
This Blob implementation is based on an underlying
Binary.Customizable mechanism for mapping
Blob instances to corresponding
serialization identifiers.A
ChangeDispatcher instance dispatches content changes
to registered Observers.A
ChildNodeEntry instance represents the child node states of a
NodeState.Interface for bearing cluster node specific information.
Utility class to manage a unique cluster/repository id for the cluster.
A CommitContext instance can be obtained from
CommitInfo.getInfo()
if it has been set before the merge call.Extension point for validating and modifying content changes.
Commit info instances associate some meta data with a commit.
A
CompositeConflictHandler delegates conflict handling
to multiple backing handlers.Aggregation of a list of editors into a single editor.
Aggregation of a list of editor providers into a single provider.
Composite commit hook.
Composite repository initializer that delegates the
CompositeInitializer.initialize(NodeBuilder) call in sequence to all the
component initializers.Composite observer that delegates all content changes to the set of
currently registered component observers.
Composite repository initializer that delegates the
CompositeWorkspaceInitializer.initialize(org.apache.jackrabbit.oak.spi.state.NodeBuilder, String)
calls in sequence to all the component initializers.This implementation of
AbstractRebaseDiff implements a NodeStateDiff,
which performs the conflict handling as defined in NodeStore.rebase(NodeBuilder)
on the Oak SPI state level by annotating conflicting items with conflict
markers.Deprecated.
Enum to define various types of conflicts.
Utility class defining the conversion that take place between
PropertyStates
of different types.A converter converts a value to its representation as a specific target type.
Editor that does nothing by default and doesn't recurse into subtrees.
MoveValidator that does nothing by default and doesn't recurse into subtrees.Node state diff handler that by default does nothing.
Validator that does nothing by default and doesn't recurse into subtrees.
Abstract base class for observers that use a content diff to determine
what changed between two consecutive observed states of the repository.
Content change editor.
This commit hook implementation processes changes to be committed
using the
Editor instance provided by the EditorProvider
passed to the constructor.Extension point for content change editors.
Basic commit hook implementation that by default doesn't do anything.
Singleton instances of empty and non-existent node states, i.e.
Basic content change observer that doesn't do anything.
Abstract base class for
PropertyState implementations
providing default implementation which correspond to a property
without any value.Helper class for comparing the equality of node states based on the
content diff mechanism.
Instances of this class represent a
Value which couldn't be retrieved.Validator that rejects all changes.
Utility class for serializing node and property states to JSON.
TODO document
Basic JavaBean implementation of a child node entry.
In-memory node state builder.
Basic in-memory node store implementation.
Immutable snapshot of a mutable node state.
A
MoveDetector is a validator that can detect certain move operations
and reports these to the wrapped MoveValidator by calling
MoveValidator.move(String, String, NodeState).Utility to keep track of the move operations that are performed between two
calls to
Root.commit(java.util.Map<java.lang.String, java.lang.Object>).A validator that also receives notifications about moved nodes.
Builder interface for constructing new
node states.A node in a content tree consists of child nodes and properties, each
of which evolves through different states during its lifecycle.
Handler of node state differences.
Utility method for code that deals with node states.
Storage abstraction for trees.
An instance of this class represents a private branch of the tree in a
NodeStore to which transient changes can be applied and later merged
back or discarded.Provides a NodeStore instance for specific role.
TODO: document
An
Observable supports attaching Observer instances for
listening to content changes.Extension point for observing changes in an Oak repository.
Deprecated.
Use
ThreeWayConflictHandler instead.Resolutions for conflicts
A partial value factory implementation that only deals with in-memory values
and can wrap a
Value around a PropertyState.Filter which determines whether given path should be included for processing
or not
Extension to the
CommitHook interface that indicates that this
commit hook implementation must be executed after the
validation hooks.Experimental
NodeStore extension that allows prefetching of node
states given a collection of paths.This
Editor instance logs invocations to the logger
passed to its constructor after each 10000 calls to it
enter() method.PropertyBuilder for building in memory PropertyState instances.Utility class for creating
PropertyState instances.A
PropertyValue implementation that wraps a PropertyStateUtility class for creating
PropertyValue instances.A node builder that throws an
UnsupportedOperationException on
all attempts to modify the given base state.Indicates that a modification operation was tried to execute on a read-only builder.
Initializer of repository content.
Default implementation of
RevisionGCMBean based on a Runnable.MBean for starting and monitoring the progress of
revision garbage collection.
This
Blob implementations is based on a string.Editor wrapper that passes only changes in the specified subtree to
the given delegate editor.
Validator that excludes a subtree from the validation process and delegates
validation of other changes to another given validator.
Validator that detects changes to a specified subtree and delegates the
validation of such changes to another given validator.
A
ThreeWayConflictHandler is responsible for handling conflicts which happen
on Root.rebase() and on the implicit rebase operation which
takes part on Root.commit().Resolutions for conflicts
TypeCodes maps between
Type and the code used to prefix
its json serialisation.Content change validator.
Extension point for plugging in different kinds of validation rules
for content changes.
Implementation of
ValueFactory interface.Editor wrapper that passes only changes to non-hidden nodes and properties
(i.e.
Validator implementation that allows to exclude hidden nodes and/or properties
for the validation process.
Dynamic
EditorProvider based on the available
whiteboard services.Initializer of a workspace and it's initial content.
ThreeWayConflictHandlerinstead.