| Modifier and Type | Method and Description |
|---|---|
NodeState |
CompositeNodeStore.getRoot() |
NodeState |
CompositeNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info) |
NodeState |
CompositeNodeStore.rebase(NodeBuilder builder) |
NodeState |
CompositeNodeStore.reset(NodeBuilder builder) |
NodeState |
CompositeNodeStore.retrieve(String checkpoint) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
ModifiedPathDiff.childNodeAdded(String name,
NodeState after) |
Validator |
CrossMountReferenceValidator.childNodeAdded(String name,
NodeState after) |
boolean |
ModifiedPathDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
Validator |
CrossMountReferenceValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
ModifiedPathDiff.childNodeDeleted(String name,
NodeState before) |
void |
CrossMountReferenceValidator.enter(NodeState before,
NodeState after) |
static Set<String> |
ModifiedPathDiff.getModifiedPaths(NodeState before,
NodeState after) |
Validator |
PrivateStoreValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
protected Validator |
CrossMountReferenceValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
void |
CrossMountReferenceValidator.leave(NodeState before,
NodeState after) |
| Constructor and Description |
|---|
CrossMountReferenceValidator(NodeState root,
MountInfoProvider mip,
boolean failOnDetection) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
ConsoleSession.getRoot()
Returns the currently set root node.
|
NodeState |
ConsoleSession.getWorkingNode()
The node state for the current working path.
|
| Constructor and Description |
|---|
ImmutableRoot(NodeState rootState) |
| Constructor and Description |
|---|
NodeStateSerializer(NodeState nodeState) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
IndexerSupport.retrieveNodeStateForCheckpoint() |
| Modifier and Type | Method and Description |
|---|---|
Editor |
SegmentPropertyIndexEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
NodeStateEntry.getNodeState() |
| Modifier and Type | Method and Description |
|---|---|
NodeStateIndexer |
NodeStateIndexerProvider.getIndexer(String type,
String indexPath,
NodeBuilder definition,
NodeState root,
IndexingProgressReporter progressReporter) |
NodeStateIndexer |
LuceneIndexerProvider.getIndexer(String type,
String indexPath,
NodeBuilder definition,
NodeState root,
IndexingProgressReporter progressReporter) |
| Constructor and Description |
|---|
NodeStateEntry(NodeState nodeState,
String path) |
NodeStateEntry(NodeState nodeState,
String path,
long memUsage) |
| Modifier and Type | Method and Description |
|---|---|
String |
NodeStateEntryWriter.asJson(NodeState nodeState) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
JsonDeserializer.deserialize(JsopReader reader) |
NodeState |
JsonDeserializer.deserialize(String json) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
JsopDiff.childNodeAdded(String name,
NodeState after) |
boolean |
JsopDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
JsopDiff.childNodeDeleted(String name,
NodeState before) |
static String |
JsopDiff.diffToJsop(NodeState before,
NodeState after)
Create the JSOP diff between
before and after for
debugging purposes. |
void |
JsonSerializer.serialize(NodeState node) |
| Constructor and Description |
|---|
GlobalNameMapper(NodeState root) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
AtomicCounterEditor.childNodeAdded(String name,
NodeState after) |
Editor |
AtomicCounterEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
AtomicCounterEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
void |
AtomicCounterEditor.leave(NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
DepthFirstNodeIterator |
DepthFirstNodeIterator.switchRoot(NodeState newRoot) |
| Constructor and Description |
|---|
DepthFirstNodeIterator(NodeState root) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
ConflictHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
COWNodeStore.getRoot() |
NodeState |
BranchNodeStore.getRoot() |
NodeState |
COWNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info) |
NodeState |
BranchNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info) |
NodeState |
COWNodeStore.rebase(NodeBuilder builder) |
NodeState |
BranchNodeStore.rebase(NodeBuilder builder) |
NodeState |
COWNodeStore.reset(NodeBuilder builder) |
NodeState |
BranchNodeStore.reset(NodeBuilder builder) |
NodeState |
COWNodeStore.retrieve(String checkpoint) |
NodeState |
BranchNodeStore.retrieve(String checkpoint) |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractDocumentNodeState |
class |
DocumentNodeState
A
NodeState implementation for the DocumentNodeStore. |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
DocumentNodeState.getChildNode(String name) |
NodeState |
DocumentNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info) |
NodeState |
DocumentNodeStore.rebase(NodeBuilder builder) |
NodeState |
DocumentNodeStore.reset(NodeBuilder builder) |
NodeState |
DocumentNodeStore.retrieve(String checkpoint) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
AbstractDocumentNodeState.compareAgainstBaseState(NodeState base,
NodeStateDiff diff) |
void |
DocumentDiscoveryLiteService.contentChanged(NodeState root,
CommitInfo info)
Additionally the DocumentDiscoveryLiteService must be notified when the
background-read has finished - as it could be waiting for a crashed
node's recovery to finish - which it can only do by checking the
lastKnownRevision of the crashed instance - and that check is best done
after the background read is just finished (it could optinoally do that
just purely time based as well, but going via a listener is more timely,
that's why this approach has been chosen).
|
void |
Commit.removeNode(String path,
NodeState state) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
BundledTypesRegistry.BundledTypesRegistryBuilder.build() |
NodeState |
BundledTypesRegistry.BundledTypesRegistryBuilder.TypeBuilder.build() |
NodeState |
BundlingHandler.getNodeState() |
| Modifier and Type | Method and Description |
|---|---|
BundlingHandler |
BundlingHandler.childAdded(String name,
NodeState state) |
BundlingHandler |
BundlingHandler.childChanged(String name,
NodeState before,
NodeState after) |
BundlingHandler |
BundlingHandler.childDeleted(String name,
NodeState state) |
void |
BundlingConfigHandler.contentChanged(NodeState root,
CommitInfo info) |
static DocumentBundlor |
DocumentBundlor.from(NodeState nodeState) |
static BundledTypesRegistry |
BundledTypesRegistry.from(NodeState configParentState) |
DocumentBundlor |
BundledTypesRegistry.getBundlor(NodeState state) |
| Modifier and Type | Class and Description |
|---|---|
class |
DelegatingDocumentNodeState
NodeState wrapper which wraps another NodeState (mostly SegmentNodeState)
so as to expose it as an
AbstractDocumentNodeState by extracting
the meta properties which are stored as hidden properties |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
DelegatingDocumentNodeState.getChildNode(String name) |
static NodeState |
DelegatingDocumentNodeState.wrapIfPossible(NodeState delegate,
NodeStateDiffer differ)
Wraps a given root NodeState as a
DelegatingDocumentNodeState if
it has required meta properties otherwise just returns the passed NodeState |
| Modifier and Type | Method and Description |
|---|---|
void |
SecondaryStoreObserver.contentChanged(NodeState root,
CommitInfo info) |
static boolean |
DelegatingDocumentNodeState.hasMetaProps(NodeState delegate) |
static AbstractDocumentNodeState |
DelegatingDocumentNodeState.wrap(NodeState delegate,
NodeStateDiffer differ) |
static NodeState |
DelegatingDocumentNodeState.wrapIfPossible(NodeState delegate,
NodeStateDiffer differ)
Wraps a given root NodeState as a
DelegatingDocumentNodeState if
it has required meta properties otherwise just returns the passed NodeState |
| Modifier and Type | Method and Description |
|---|---|
boolean |
CountingDiff.childNodeAdded(String name,
NodeState after) |
boolean |
CountingDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
CountingDiff.childNodeDeleted(String name,
NodeState before) |
static int |
CountingDiff.countChanges(NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
IdentifierTracker |
IdentifierTracker.getChildTracker(String name,
NodeState state) |
| Constructor and Description |
|---|
IdentifierTracker(NodeState root) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
IndexUpdate.childNodeAdded(String name,
NodeState after) |
Editor |
IndexUpdate.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
IndexUpdate.childNodeDeleted(String name,
NodeState before) |
void |
IndexUpdate.enter(NodeState before,
NodeState after) |
static String |
IndexUtils.getAsyncLaneName(NodeState idxState,
String indexPath) |
static String |
IndexUtils.getAsyncLaneName(NodeState idxState,
String indexPath,
PropertyState async) |
Iterable<String> |
AsyncIndexInfoServiceImpl.getAsyncLanes(NodeState root) |
Iterable<String> |
AsyncIndexInfoService.getAsyncLanes(NodeState root)
Returns all the async indexing lanes which are active
in the setup based on given root NodeState
|
Editor |
WhiteboardIndexEditorProvider.getIndexEditor(String type,
NodeBuilder builder,
NodeState root,
IndexUpdateCallback callback) |
Editor |
IndexEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback)
Each provider knows how to produce a certain type of index.
|
Editor |
CompositeIndexEditorProvider.getIndexEditor(String type,
NodeBuilder builder,
NodeState root,
IndexUpdateCallback callback) |
Map<String,Long> |
AsyncIndexInfoServiceImpl.getIndexedUptoPerLane(NodeState root) |
Map<String,Long> |
AsyncIndexInfoService.getIndexedUptoPerLane(NodeState root)
Returns the lastIndexUpto time in millis for each indexing lane
for given root state
|
AsyncIndexInfo |
AsyncIndexInfoServiceImpl.getInfo(String name,
NodeState root) |
AsyncIndexInfo |
AsyncIndexInfoService.getInfo(String name,
NodeState root)
Returns the info for async indexer with given name
and based on given root NodeState
|
Editor |
IndexUpdateProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
default boolean |
AsyncIndexInfoService.hasIndexerUpdatedForAnyLane(NodeState before,
NodeState after)
Determines if any index lane has completed any indexing cycle between given
two repository states
|
static boolean |
IndexUtils.isIndexNodeType(NodeState state) |
static boolean |
IndexUtils.isIndexNodeType(NodeState state,
String typeIn) |
void |
IndexUpdate.leave(NodeState before,
NodeState after) |
static Cursor |
Cursors.newTraversingCursor(Filter filter,
NodeState rootState)
Returns a traversing cursor based on the path restriction in the given
Filter. |
protected boolean |
AsyncIndexUpdate.updateIndex(NodeState before,
String beforeCheckpoint,
NodeState after,
String afterCheckpoint,
String afterTime,
AsyncIndexUpdate.AsyncUpdateCallback callback) |
| Constructor and Description |
|---|
IndexUpdate(IndexEditorProvider provider,
String async,
NodeState root,
NodeBuilder builder,
IndexUpdateCallback updateCallback) |
IndexUpdate(IndexEditorProvider provider,
String async,
NodeState root,
NodeBuilder builder,
IndexUpdateCallback updateCallback,
CommitInfo commitInfo) |
IndexUpdate(IndexEditorProvider provider,
String async,
NodeState root,
NodeBuilder builder,
IndexUpdateCallback updateCallback,
NodeTraversalCallback traversalCallback,
CommitInfo commitInfo,
CorruptIndexHandler corruptIndexHandler) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
AggregateIndexPlan.getDefinition() |
| Modifier and Type | Method and Description |
|---|---|
double |
AggregateIndex.getCost(Filter filter,
NodeState rootState) |
Iterator<String> |
SimpleNodeAggregator.getParents(NodeState root,
String path) |
String |
AggregateIndex.getPlan(Filter filter,
NodeState rootState) |
String |
AggregateIndex.getPlanDescription(QueryIndex.IndexPlan plan,
NodeState root) |
List<QueryIndex.IndexPlan> |
AggregateIndex.getPlans(Filter filter,
List<QueryIndex.OrderEntry> sortOrder,
NodeState rootState) |
List<? extends QueryIndex> |
AggregateIndexProvider.getQueryIndexes(NodeState state) |
Cursor |
AggregateIndex.query(Filter filter,
NodeState rootState) |
Cursor |
AggregateIndex.query(QueryIndex.IndexPlan plan,
NodeState rootState) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
NodeCounterEditorOld.childNodeAdded(String name,
NodeState after)
Deprecated.
|
Editor |
NodeCounterEditor.childNodeAdded(String name,
NodeState after) |
Editor |
NodeCounterEditorOld.childNodeChanged(String name,
NodeState before,
NodeState after)
Deprecated.
|
Editor |
NodeCounterEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
NodeCounterEditorOld.childNodeDeleted(String name,
NodeState before)
Deprecated.
|
Editor |
NodeCounterEditor.childNodeDeleted(String name,
NodeState before) |
void |
NodeCounterEditorOld.enter(NodeState before,
NodeState after)
Deprecated.
|
void |
NodeCounterEditor.enter(NodeState before,
NodeState after) |
static long |
ApproximateCounter.getCountSync(NodeState node)
Get the count estimation.
|
Editor |
NodeCounterEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
void |
NodeCounterEditorOld.leave(NodeState before,
NodeState after)
Deprecated.
|
void |
NodeCounterEditor.leave(NodeState before,
NodeState after) |
void |
NodeCounterEditorOld.leaveNew(NodeState before,
NodeState after)
Deprecated.
|
void |
NodeCounterEditor.leaveNew(NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
static long |
NodeCounterOld.getEstimatedNodeCount(NodeState root,
String path,
boolean max)
Deprecated.
Get the estimated number of nodes for a given path.
|
static long |
NodeCounter.getEstimatedNodeCount(NodeState root,
String path,
boolean max)
Get the estimated number of nodes for a given path.
|
| Modifier and Type | Method and Description |
|---|---|
double |
DiffIndex.getCost(Filter filter,
NodeState rootState) |
String |
DiffIndex.getPlan(Filter filter,
NodeState rootState) |
List<? extends QueryIndex> |
UUIDDiffIndexProviderWrapper.getQueryIndexes(NodeState nodeState) |
protected boolean |
UUIDDiffCollector.match(NodeState state,
Filter filter) |
Cursor |
DiffIndex.query(Filter filter,
NodeState rootState) |
| Constructor and Description |
|---|
BaseDiffCollector(NodeState before,
NodeState after) |
UUIDDiffCollector(NodeState before,
NodeState after) |
UUIDDiffIndex(NodeState before,
NodeState after) |
UUIDDiffIndexProviderWrapper(QueryIndexProvider baseProvider,
NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
IndexDefinitionUpdater.getIndexState(String indexPath) |
| Modifier and Type | Method and Description |
|---|---|
void |
IndexImporterProvider.importIndex(NodeState root,
NodeBuilder defn,
File indexDir)
Import the index data from given directory into the
NodeBuilder created for the index at given path
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
IndexDefinition.getDefinitionNodeState() |
| Modifier and Type | Method and Description |
|---|---|
boolean |
IndexDefinition.IndexingRule.appliesTo(NodeState state)
Returns
true if this rule applies to the given node
state. |
Editor |
LuceneIndexEditor.childNodeAdded(String name,
NodeState after) |
Editor |
LuceneIndexEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
LuceneIndexEditor.childNodeDeleted(String name,
NodeState before) |
void |
LuceneIndexProvider.contentChanged(NodeState root,
CommitInfo info) |
void |
LuceneIndexEditor.enter(NodeState before,
NodeState after) |
IndexDefinition.IndexingRule |
IndexDefinition.getApplicableIndexingRule(NodeState state)
Returns the first indexing rule that applies to the given node
state. |
double |
LucenePropertyIndex.getCost(Filter filter,
NodeState root) |
double |
LuceneIndex.getCost(Filter filter,
NodeState root) |
Editor |
LuceneIndexEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
String |
LucenePropertyIndex.getPlan(Filter filter,
NodeState root) |
String |
LuceneIndex.getPlan(Filter filter,
NodeState root) |
String |
LucenePropertyIndex.getPlanDescription(QueryIndex.IndexPlan plan,
NodeState root) |
String |
LuceneIndex.getPlanDescription(QueryIndex.IndexPlan plan,
NodeState root) |
List<QueryIndex.IndexPlan> |
LucenePropertyIndex.getPlans(Filter filter,
List<QueryIndex.OrderEntry> sortOrder,
NodeState rootState) |
List<QueryIndex.IndexPlan> |
LuceneIndex.getPlans(Filter filter,
List<QueryIndex.OrderEntry> sortOrder,
NodeState rootState) |
List<QueryIndex> |
LuceneIndexProvider.getQueryIndexes(NodeState nodeState) |
boolean |
IndexDefinition.hasMatchingNodeTypeReg(NodeState root) |
static boolean |
IndexDefinition.hasPersistedIndex(NodeState definition)
Check if the index definition is fresh of some index has happened
|
void |
LuceneIndexEditor.leave(NodeState before,
NodeState after) |
org.apache.lucene.document.Document |
LuceneDocumentMaker.makeDocument(NodeState state) |
org.apache.lucene.document.Document |
LuceneDocumentMaker.makeDocument(NodeState state,
boolean isUpdate,
List<PropertyState> propertiesModified) |
static IndexDefinition.Builder |
IndexDefinition.newBuilder(NodeState root,
NodeState defn,
String indexPath) |
Cursor |
LucenePropertyIndex.query(Filter filter,
NodeState root) |
Cursor |
LuceneIndex.query(Filter filter,
NodeState root) |
Cursor |
LucenePropertyIndex.query(QueryIndex.IndexPlan plan,
NodeState rootState) |
Cursor |
LuceneIndex.query(QueryIndex.IndexPlan plan,
NodeState rootState) |
void |
IndexTracker.update(NodeState root) |
| Constructor and Description |
|---|
Builder(NodeState root,
NodeState defn,
String indexPath) |
IndexDefinition(NodeState root,
NodeState defn,
String indexPath) |
PropertyDefinition(IndexDefinition.IndexingRule idxDefn,
String nodeName,
NodeState defn) |
ReindexOperations(NodeState root,
NodeBuilder definitionBuilder,
String indexPath) |
| Modifier and Type | Method and Description |
|---|---|
List<org.apache.lucene.document.Field> |
BinaryTextExtractor.newBinary(PropertyState property,
NodeState state,
String nodePath,
String path) |
| Modifier and Type | Method and Description |
|---|---|
void |
LuceneIndexImporter.importIndex(NodeState root,
NodeBuilder definitionBuilder,
File indexDir) |
| Constructor and Description |
|---|
IndexConsistencyChecker(NodeState rootState,
String indexPath,
File workDirRoot)
Checks the index at given path for consistency
|
LuceneIndexDumper(NodeState rootState,
String indexPath,
File baseDir)
Constructs the dumper for copying Lucene index contents
|
| Modifier and Type | Method and Description |
|---|---|
void |
LocalIndexObserver.contentChanged(NodeState root,
CommitInfo info) |
| Constructor and Description |
|---|
HybridPropertyIndexInfo(NodeState idx) |
HybridPropertyIndexLookup(String indexPath,
NodeState indexState) |
HybridPropertyIndexLookup(String indexPath,
NodeState indexState,
String pathPrefix,
boolean prependPathPrefix) |
PropertyIndexUpdateCallback(String indexPath,
NodeBuilder builder,
NodeState rootState) |
PropertyIndexUpdateCallback(String indexPath,
NodeBuilder builder,
NodeState rootState,
Clock clock) |
UniquenessConstraintValidator(String indexPath,
NodeBuilder builder,
NodeState rootState) |
| Modifier and Type | Method and Description |
|---|---|
List<LuceneIndexReader> |
LuceneIndexReaderFactory.createReaders(IndexDefinition definition,
NodeState definitionState,
String indexPath) |
List<LuceneIndexReader> |
DefaultIndexReaderFactory.createReaders(IndexDefinition definition,
NodeState defnState,
String indexPath) |
| Modifier and Type | Method and Description |
|---|---|
Iterable<org.apache.lucene.document.Field> |
IndexFieldProvider.getAugmentedFields(String path,
NodeState document,
NodeState indexDefinition)
This method would get called while indexing a document.
|
org.apache.lucene.search.Query |
FulltextQueryTermsProvider.getQueryTerm(String text,
org.apache.lucene.analysis.Analyzer analyzer,
NodeState indexDefinition)
This method would get called while forming full text clause for full text clause not constrained on a particular
field.
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
IndexDefinitionBuilder.build() |
| Modifier and Type | Method and Description |
|---|---|
static Blob |
ConfigUtil.getBlob(NodeState state,
String resourceName)
Assumes that given state is of type nt:file and then reads
the jcr:content/@jcr:data property to get the binary content
|
static Iterable<String> |
ConfigUtil.getMixinNames(NodeState nodeState) |
static boolean |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
boolean defaultVal) |
static double |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
double defaultVal) |
static float |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
float defaultVal) |
static int |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
int defaultVal) |
static String |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
String defaultVal) |
static String |
ConfigUtil.getPrimaryTypeName(NodeState nodeState) |
static boolean |
LuceneIndexHelper.isLuceneIndexNode(NodeState node) |
static PropertyState |
FunctionIndexProcessor.tryCalculateValue(String path,
NodeState state,
String[] functionCode)
Try to calculate the value for the given function code.
|
| Modifier and Type | Method and Description |
|---|---|
org.apache.lucene.search.Query |
MTFulltextQueryTermsProviderFactory.getQueryTerm(String text,
org.apache.lucene.analysis.Analyzer analyzer,
NodeState indexDefinition) |
org.apache.lucene.search.Query |
MTFulltextQueryTermsProvider.getQueryTerm(String text,
org.apache.lucene.analysis.Analyzer analyzer,
NodeState indexDefinition) |
| Modifier and Type | Method and Description |
|---|---|
List<? extends QueryIndex> |
NodeTypeIndexProvider.getQueryIndexes(NodeState nodeState) |
| Modifier and Type | Method and Description |
|---|---|
static OrderedIndex.OrderDirection |
OrderedIndex.OrderDirection.fromIndexMeta(NodeState indexMeta)
tells whether the provided index definition is ascending or descending
|
Editor |
PropertyIndexEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
Editor |
OrderedPropertyIndexEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
List<QueryIndex> |
PropertyIndexProvider.getQueryIndexes(NodeState state) |
List<? extends QueryIndex> |
OrderedPropertyIndexProvider.getQueryIndexes(NodeState nodeState) |
static Set<IndexStoreStrategy> |
Multiplexers.getStrategies(boolean unique,
MountInfoProvider mountInfoProvider,
NodeState definition,
String defaultName) |
static Iterable<String> |
ValuePattern.getStrings(NodeState node,
String propertyName) |
static boolean |
OrderedIndex.OrderDirection.isAscending(NodeState indexMeta)
convenience method that tells if the provided index definition is ascending
|
static boolean |
OrderedIndex.OrderDirection.isDescending(NodeState indexMeta)
convenience method that tells if the provided index definition is descending
|
| Constructor and Description |
|---|
PropertyIndexLookup(NodeState root) |
PropertyIndexLookup(NodeState root,
MountInfoProvider mountInfoProvider) |
ValuePattern(NodeState node) |
| Modifier and Type | Method and Description |
|---|---|
long |
UniqueEntryStoreStrategy.count(Filter filter,
NodeState root,
NodeState indexMeta,
Set<String> values,
int max) |
long |
IndexStoreStrategy.count(Filter filter,
NodeState root,
NodeState indexMeta,
Set<String> values,
int max)
Count the occurrence of a given set of values.
|
long |
FilteringIndexStoreStrategy.count(Filter filter,
NodeState root,
NodeState indexMeta,
Set<String> values,
int max) |
long |
ContentMirrorStoreStrategy.count(Filter filter,
NodeState root,
NodeState indexMeta,
Set<String> values,
int max) |
long |
UniqueEntryStoreStrategy.count(NodeState root,
NodeState indexMeta,
Set<String> values,
int max) |
long |
IndexStoreStrategy.count(NodeState root,
NodeState indexMeta,
Set<String> values,
int max)
Count the occurrence of a given set of values.
|
long |
FilteringIndexStoreStrategy.count(NodeState root,
NodeState indexMeta,
Set<String> values,
int max) |
long |
ContentMirrorStoreStrategy.count(NodeState root,
NodeState indexMeta,
Set<String> values,
int max) |
Iterable<String> |
UniqueEntryStoreStrategy.query(Filter filter,
String indexName,
NodeState indexMeta,
Iterable<String> values) |
Iterable<String> |
IndexStoreStrategy.query(Filter filter,
String indexName,
NodeState indexMeta,
Iterable<String> values)
Search for a given set of values.
|
Iterable<String> |
FilteringIndexStoreStrategy.query(Filter filter,
String indexName,
NodeState indexMeta,
Iterable<String> values) |
Iterable<String> |
ContentMirrorStoreStrategy.query(Filter filter,
String name,
NodeState indexMeta,
Iterable<String> values) |
Iterable<String> |
ContentMirrorStoreStrategy.query(Filter filter,
String indexName,
NodeState indexMeta,
String indexStorageNodeName,
Iterable<String> values) |
Iterable<IndexEntry> |
UniqueEntryStoreStrategy.queryEntries(Filter filter,
String indexName,
NodeState indexMeta,
Iterable<String> values)
Search for a given set of values, returning IndexEntry results
|
| Modifier and Type | Method and Description |
|---|---|
Editor |
ReferenceEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
List<QueryIndex> |
ReferenceIndexProvider.getQueryIndexes(NodeState state) |
| Modifier and Type | Field and Description |
|---|---|
NodeState |
Aggregate.NodeIncludeResult.nodeState |
| Modifier and Type | Method and Description |
|---|---|
static NodeState |
NodeStateCloner.cloneVisibleState(NodeState state) |
NodeState |
IndexDefinition.getDefinitionNodeState() |
| Modifier and Type | Method and Description |
|---|---|
boolean |
IndexDefinition.IndexingRule.appliesTo(NodeState state)
Returns
true if this rule applies to the given node
state. |
static NodeState |
NodeStateCloner.cloneVisibleState(NodeState state) |
void |
Aggregate.collectAggregates(NodeState root,
Aggregate.ResultCollector collector) |
static void |
IndexLookup.collectIndexNodePaths(NodeState nodeState,
String type,
String parentPath,
Collection<String> paths) |
void |
Aggregate.NodeInclude.collectResults(Aggregate.NodeInclude rootInclude,
String rootIncludePath,
String nodePath,
NodeState nodeState,
Aggregate.ResultCollector results) |
void |
Aggregate.Include.collectResults(String nodePath,
NodeState nodeState,
Aggregate.ResultCollector results) |
void |
Aggregate.PropertyInclude.collectResults(String nodePath,
NodeState nodeState,
Aggregate.ResultCollector results) |
void |
Aggregate.Include.collectResults(T rootInclude,
String rootIncludePath,
String nodePath,
NodeState nodeState,
Aggregate.ResultCollector results) |
Aggregate |
Aggregate.Include.getAggregate(NodeState matchedNodeState) |
Aggregate |
Aggregate.NodeInclude.getAggregate(NodeState matchedNodeState) |
IndexDefinition.IndexingRule |
IndexDefinition.getApplicableIndexingRule(NodeState state)
Returns the first indexing rule that applies to the given node
state. |
boolean |
IndexDefinition.hasMatchingNodeTypeReg(NodeState root) |
static boolean |
IndexDefinition.hasPersistedIndex(NodeState definition)
Check if the index definition is fresh of some index has happened
|
Aggregate.Matcher |
Aggregate.Matcher.match(String name,
NodeState nodeState) |
boolean |
Aggregate.Include.match(String name,
NodeState nodeState,
int depth) |
boolean |
Aggregate.NodeInclude.match(String name,
NodeState nodeState,
int depth) |
static IndexDefinition.Builder |
IndexDefinition.newBuilder(NodeState root,
NodeState defn,
String indexPath) |
| Constructor and Description |
|---|
Builder(NodeState root,
NodeState defn,
String indexPath) |
IndexDefinition(NodeState root,
NodeState defn,
String indexPath) |
IndexLookup(NodeState root) |
NodeIncludeResult(String nodePath,
NodeState nodeState) |
NodeIncludeResult(String nodePath,
String rootIncludePath,
NodeState nodeState) |
PropertyDefinition(IndexDefinition.IndexingRule idxDefn,
String nodeName,
NodeState defn) |
ReindexOperations(NodeState root,
NodeBuilder definitionBuilder,
String indexPath) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
FulltextIndexEditor.childNodeAdded(String name,
NodeState after) |
Editor |
FulltextIndexEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
FulltextIndexEditor.childNodeDeleted(String name,
NodeState before) |
void |
FulltextIndexEditor.enter(NodeState before,
NodeState after) |
void |
FulltextIndexEditor.leave(NodeState before,
NodeState after) |
D |
FulltextDocumentMaker.makeDocument(NodeState state) |
D |
FulltextDocumentMaker.makeDocument(NodeState state,
boolean isUpdate,
List<PropertyState> propertiesModified) |
D |
DocumentMaker.makeDocument(NodeState state,
boolean isUpdate,
List<PropertyState> propertiesModified)
create a document from the current state and list of modified properties
|
Map<String,String> |
FulltextBinaryTextExtractor.newBinary(PropertyState property,
NodeState state,
String nodePath,
String path) |
| Constructor and Description |
|---|
FulltextIndexEditorContext(NodeState root,
NodeBuilder definition,
IndexDefinition indexDefinition,
IndexUpdateCallback updateCallback,
FulltextIndexWriterFactory indexWriterFactory,
ExtractedTextCache extractedTextCache,
IndexingContext indexingContext,
boolean asyncIndexing) |
| Modifier and Type | Method and Description |
|---|---|
double |
FulltextIndex.getCost(Filter filter,
NodeState root) |
String |
FulltextIndex.getPlan(Filter filter,
NodeState root) |
String |
FulltextIndex.getPlanDescription(QueryIndex.IndexPlan plan,
NodeState root) |
List<QueryIndex.IndexPlan> |
FulltextIndex.getPlans(Filter filter,
List<QueryIndex.OrderEntry> sortOrder,
NodeState rootState) |
protected abstract IndexNodeManager |
IndexNodeManager.open(String indexPath,
NodeState root,
NodeState defnNodeState) |
protected abstract IndexNodeManager |
FulltextIndexTracker.openIndex(String path,
NodeState root,
NodeState node) |
Cursor |
FulltextIndex.query(Filter filter,
NodeState root) |
void |
FulltextIndexTracker.update(NodeState root) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
IndexDefinitionBuilder.build() |
| Modifier and Type | Method and Description |
|---|---|
static Blob |
ConfigUtil.getBlob(NodeState state,
String resourceName)
Assumes that given state is of type nt:file and then reads
the jcr:content/@jcr:data property to get the binary content
|
static Iterable<String> |
ConfigUtil.getMixinNames(NodeState nodeState) |
static boolean |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
boolean defaultVal) |
static double |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
double defaultVal) |
static float |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
float defaultVal) |
static int |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
int defaultVal) |
static String |
ConfigUtil.getOptionalValue(NodeState definition,
String propName,
String defaultVal) |
static String |
ConfigUtil.getPrimaryTypeName(NodeState nodeState) |
static boolean |
IndexHelper.isIndexNodeOfType(NodeState node,
String type) |
static PropertyState |
FunctionIndexProcessor.tryCalculateValue(String path,
NodeState state,
String[] functionCode)
Try to calculate the value for the given function code.
|
| Modifier and Type | Method and Description |
|---|---|
protected NodeStateDiff |
NodeStateSolrServersObserver.getRootDiff(NodeState before,
NodeState after,
CommitInfo info) |
| Constructor and Description |
|---|
NodeStateSolrServerConfigurationProvider(NodeState nodeState) |
NodeStateSolrServerProvider(NodeState nodeState) |
OakSolrNodeStateConfiguration(NodeState definition) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
SolrIndexEditorProvider.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
SolrIndexEditorProviderService.getIndexEditor(String type,
NodeBuilder definition,
NodeState root,
IndexUpdateCallback callback) |
| Modifier and Type | Method and Description |
|---|---|
double |
SolrQueryIndex.getCost(Filter filter,
NodeState root) |
String |
SolrQueryIndex.getPlan(Filter filter,
NodeState nodeState) |
String |
SolrQueryIndex.getPlanDescription(QueryIndex.IndexPlan plan,
NodeState root) |
List<QueryIndex.IndexPlan> |
SolrQueryIndex.getPlans(Filter filter,
List<QueryIndex.OrderEntry> sortOrder,
NodeState rootState) |
List<? extends QueryIndex> |
SolrQueryIndexProvider.getQueryIndexes(NodeState nodeState) |
Cursor |
SolrQueryIndex.query(Filter filter,
NodeState rootState) |
Cursor |
SolrQueryIndex.query(QueryIndex.IndexPlan plan,
NodeState root) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
SolrIndexInitializer.isSolrIndexNode(NodeState node) |
| Modifier and Type | Method and Description |
|---|---|
protected Validator |
ItemSaveValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Class and Description |
|---|---|
class |
EmptyNodeState
Singleton instances of empty and non-existent node states, i.e.
|
class |
ModifiedNodeState
Immutable snapshot of a mutable node state.
|
| Modifier and Type | Field and Description |
|---|---|
static NodeState |
EmptyNodeState.EMPTY_NODE |
static NodeState |
EmptyNodeState.MISSING_NODE |
| Modifier and Type | Method and Description |
|---|---|
static <E extends Map.Entry<String,? extends NodeState>> |
MemoryChildNodeEntry.iterable(Iterable<E> set) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
ModifiedNodeState.getBaseState() |
NodeState |
MemoryNodeBuilder.getBaseState() |
NodeState |
ModifiedNodeState.getChildNode(String name) |
NodeState |
EmptyNodeState.getChildNode(String name) |
NodeState |
MemoryNodeBuilder.getNodeState() |
NodeState |
MemoryChildNodeEntry.getNodeState() |
NodeState |
MemoryNodeStore.getRoot() |
NodeState |
MemoryNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info)
This implementation is equal to first rebasing the builder and then applying it to a
new branch and immediately merging it back.
|
NodeState |
MemoryNodeStore.rebase(NodeBuilder builder)
This implementation is equal to applying the differences between the builders base state
and its head state to a fresh builder on the stores root state using
ConflictAnnotatingRebaseDiff for resolving
conflicts. |
NodeState |
MemoryNodeStore.reset(NodeBuilder builder)
This implementation is equal resetting the builder to the root of the store and returning
the resulting node state from the builder.
|
NodeState |
MemoryNodeStore.retrieve(String checkpoint) |
static NodeState |
ModifiedNodeState.squeeze(NodeState state)
"Squeezes"
ModifiedNodeState instances into equivalent
MemoryNodeStates. |
| Modifier and Type | Method and Description |
|---|---|
boolean |
ModifiedNodeState.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. |
boolean |
EmptyNodeState.compareAgainstBaseState(NodeState base,
NodeStateDiff diff) |
static boolean |
EmptyNodeState.compareAgainstEmptyState(NodeState state,
NodeStateDiff diff) |
static boolean |
EmptyNodeState.isEmptyState(NodeState state) |
void |
MemoryNodeBuilder.reset(NodeState newBase)
Throws away all changes in this builder and resets the base to the
given node state.
|
protected void |
MemoryNodeBuilder.set(NodeState newState)
Replaces the current state of this builder with the given node state.
|
NodeBuilder |
MemoryNodeBuilder.setChildNode(String name,
NodeState state) |
static NodeState |
ModifiedNodeState.squeeze(NodeState state)
"Squeezes"
ModifiedNodeState instances into equivalent
MemoryNodeStates. |
| Constructor and Description |
|---|
MemoryChildNodeEntry(String name,
NodeState node)
Creates a child node entry with the given name and referenced
child node state.
|
MemoryNodeBuilder(NodeState base)
Creates a new in-memory node state builder rooted at
and based on the passed
base state. |
MemoryNodeStore(NodeState state) |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractDecoratedNodeState |
class |
FilteringNodeState
NodeState implementation that decorates another node-state instance
in order to hide subtrees or partial subtrees from the consumer of
the API.
|
| Modifier and Type | Field and Description |
|---|---|
protected NodeState |
AbstractDecoratedNodeState.delegate |
| Modifier and Type | Method and Description |
|---|---|
protected NodeState |
FilteringNodeState.decorateChild(String name,
NodeState child) |
protected abstract NodeState |
AbstractDecoratedNodeState.decorateChild(String name,
NodeState delegateChild) |
NodeState |
AbstractDecoratedNodeState.getChildNode(String name) |
NodeState |
AbstractDecoratedNodeState.getDelegate() |
static NodeState |
FilteringNodeState.wrap(String path,
NodeState delegate,
Set<String> includePaths,
Set<String> excludePaths,
Set<String> fragmentPaths,
Set<String> excludedFragments)
Factory method that conditionally decorates the given node-state
iff the node-state is (a) hidden itself or (b) has hidden descendants.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
AbstractDecoratedNodeState.compareAgainstBaseState(NodeState base,
NodeStateDiff diff) |
boolean |
NodeStateCopier.Builder.copy(NodeState sourceRoot,
NodeBuilder targetRoot)
Creates a NodeStateCopier to copy the
sourceRoot NodeState to the
targetRoot NodeBuilder, using any include, exclude and merge paths
set on this NodeStateCopier.Builder. |
static boolean |
NodeStateCopier.copyProperties(NodeState source,
NodeBuilder target)
Copies all changed properties from the source NodeState to the target
NodeBuilder instance.
|
protected NodeState |
FilteringNodeState.decorateChild(String name,
NodeState child) |
protected abstract NodeState |
AbstractDecoratedNodeState.decorateChild(String name,
NodeState delegateChild) |
protected static PropertyState |
AbstractDecoratedNodeState.fixChildOrderPropertyState(NodeState nodeState,
PropertyState propertyState)
Convenience method to help implementations that hide nodes set the
:childOrder (OAK_CHILD_ORDER) property to its correct value.
|
protected boolean |
FilteringNodeState.hideChild(String name,
NodeState delegateChild) |
protected boolean |
AbstractDecoratedNodeState.hideChild(String name,
NodeState delegateChild) |
static NodeState |
FilteringNodeState.wrap(String path,
NodeState delegate,
Set<String> includePaths,
Set<String> excludePaths,
Set<String> fragmentPaths,
Set<String> excludedFragments)
Factory method that conditionally decorates the given node-state
iff the node-state is (a) hidden itself or (b) has hidden descendants.
|
| Constructor and Description |
|---|
AbstractDecoratedNodeState(NodeState delegate) |
| Modifier and Type | Class and Description |
|---|---|
class |
ReportingNodeState
A decoration layer for NodeState instances that intercepts
all accesses to NodeStates and PropertyStates (getters) and
informs a
Reporter via its callbacks that the respective
NodeStates or PropertyStates have been accessed. |
| Modifier and Type | Method and Description |
|---|---|
protected NodeState |
ReportingNodeState.decorateChild(String name,
NodeState delegateChild) |
static NodeState |
ReportingNodeState.wrap(NodeState nodeState,
Reporter reporter)
Allows wrapping a NodeState as a ReportingNodeState.
|
| Modifier and Type | Method and Description |
|---|---|
protected NodeState |
ReportingNodeState.decorateChild(String name,
NodeState delegateChild) |
static NodeState |
ReportingNodeState.wrap(NodeState nodeState,
Reporter reporter)
Allows wrapping a NodeState as a ReportingNodeState.
|
| Modifier and Type | Method and Description |
|---|---|
Editor |
NamespaceEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
Validator |
NameValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
TypePredicate.apply(NodeState input) |
Editor |
TypeEditor.childNodeAdded(String name,
NodeState after) |
TypeEditor |
TypeEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
TypeEditor.childNodeDeleted(String name,
NodeState before) |
static TypeEditor |
TypeEditor.create(TypeEditor.ConstraintViolationCallback callback,
Set<String> typesToCheck,
NodeState types,
String primary,
Iterable<String> mixins,
NodeBuilder builder)
Creates a new TypeEditor instance
|
void |
TypeEditor.enter(NodeState before,
NodeState after) |
Editor |
TypeEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
static TypePredicate |
TypePredicate.isOrderable(NodeState root) |
| Constructor and Description |
|---|
TypePredicate(NodeState root,
Iterable<String> names)
Creates a predicate for checking whether a node state is an instance of
any of the named node types.
|
TypePredicate(NodeState root,
String name)
Creates a predicate for checking whether a node state is an instance of
the named node type.
|
TypePredicate(NodeState root,
String[] names)
Creates a predicate for checking whether a node state is an instance of
any of the named node types.
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
CommitRateLimiter.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
void |
EventGenerator.addHandler(NodeState before,
NodeState after,
EventHandler handler) |
void |
NodeObserver.contentChanged(NodeState root,
CommitInfo info) |
void |
FilteringObserver.contentChanged(NodeState root,
CommitInfo info) |
void |
FilteringDispatcher.contentChanged(NodeState root,
CommitInfo info) |
void |
FilteringAwareObserver.contentChanged(NodeState before,
NodeState after,
CommitInfo info)
Equivalent to the state-full contentChanged() method of the Observer
with one important difference being that this variation explicitly
passes the before NodeState (thus the observer must in this case
not remember the previous state)
|
void |
FilteredHandler.enter(NodeState before,
NodeState after) |
void |
EventHandler.enter(NodeState before,
NodeState after)
Called before the given before and after states are compared.
|
void |
DefaultEventHandler.enter(NodeState before,
NodeState after) |
boolean |
Filter.excludes(NodeState root,
CommitInfo info)
Whether or not to exclude a particular content change from being
forwarded to downstream observers.
|
EventHandler |
FilteredHandler.getChildHandler(String name,
NodeState before,
NodeState after) |
EventHandler |
EventHandler.getChildHandler(String name,
NodeState before,
NodeState after)
Returns a handler of events within the given child node, or
null if changes within that child are not to be processed. |
EventHandler |
DefaultEventHandler.getChildHandler(String name,
NodeState before,
NodeState after) |
protected Validator |
ChangeCollectorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
void |
FilteredHandler.leave(NodeState before,
NodeState after) |
void |
EventHandler.leave(NodeState before,
NodeState after)
Called after the given before and after states are compared.
|
void |
DefaultEventHandler.leave(NodeState before,
NodeState after) |
void |
FilteredHandler.nodeAdded(String name,
NodeState after) |
void |
EventHandler.nodeAdded(String name,
NodeState after)
Notification for an added node
|
void |
DefaultEventHandler.nodeAdded(String name,
NodeState after) |
void |
FilteredHandler.nodeDeleted(String name,
NodeState before) |
void |
EventHandler.nodeDeleted(String name,
NodeState before)
Notification for a deleted node
|
void |
DefaultEventHandler.nodeDeleted(String name,
NodeState before) |
void |
FilteredHandler.nodeMoved(String sourcePath,
String name,
NodeState moved) |
void |
EventHandler.nodeMoved(String sourcePath,
String name,
NodeState moved)
Notification for a moved node
|
void |
DefaultEventHandler.nodeMoved(String sourcePath,
String name,
NodeState moved) |
void |
FilteredHandler.nodeReordered(String destName,
String name,
NodeState reordered) |
void |
EventHandler.nodeReordered(String destName,
String name,
NodeState reordered)
Notification for a reordered node
|
void |
DefaultEventHandler.nodeReordered(String destName,
String name,
NodeState reordered) |
NodeState |
CommitRateLimiter.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Constructor and Description |
|---|
EventGenerator(NodeState before,
NodeState after,
EventHandler handler)
Creates a new generator instance for processing the given changes.
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
UniversalFilter.getAfterState() |
NodeState |
UniversalFilter.getBeforeState() |
NodeState |
UniversalFilter.Selector.select(UniversalFilter filter,
PropertyState before,
PropertyState after)
Map a property event.
|
NodeState |
RelativePathSelector.select(UniversalFilter filter,
PropertyState before,
PropertyState after) |
NodeState |
UniversalFilter.Selector.select(UniversalFilter filter,
String name,
NodeState before,
NodeState after)
Map a node event.
|
NodeState |
RelativePathSelector.select(UniversalFilter filter,
String name,
NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
int |
EventAggregator.aggregate(NodeState root,
List<ChildNodeEntry> parents,
ChildNodeEntry childNodeState)
Aggregates a node change
|
int |
EventAggregator.aggregate(NodeState root,
List<ChildNodeEntry> parents,
PropertyState propertyState)
Aggregates a property change
|
boolean |
UuidPredicate.apply(NodeState node) |
boolean |
PropertyPredicate.apply(NodeState node) |
EventFilter |
VisibleFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
UniversalFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
MoveFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
GlobbingPathFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
EventTypeFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
EventFilter.create(String name,
NodeState before,
NodeState after)
Factory for creating a filter instance for the given child node
|
EventFilter |
DeleteSubtreeFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
ConstantFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
AddSubtreeFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
ACFilter.create(String name,
NodeState before,
NodeState after) |
EventFilter |
FilterBuilder.Condition.createFilter(NodeState before,
NodeState after) |
EventFilter |
FilterBuilder.AddSubtreeTreeCondition.createFilter(NodeState before,
NodeState after) |
EventFilter |
FilterBuilder.DeleteSubtreeTreeCondition.createFilter(NodeState before,
NodeState after) |
EventFilter |
FilterBuilder.MoveCondition.createFilter(NodeState before,
NodeState after) |
EventFilter |
FilterProvider.getFilter(NodeState before,
NodeState after)
Factory method for creating a
Filter for the passed before and after
states. |
boolean |
VisibleFilter.includeAdd(String name,
NodeState after) |
boolean |
UniversalFilter.includeAdd(String name,
NodeState after) |
boolean |
MoveFilter.includeAdd(String name,
NodeState after) |
boolean |
GlobbingPathFilter.includeAdd(String name,
NodeState after) |
boolean |
EventTypeFilter.includeAdd(String name,
NodeState after) |
boolean |
EventFilter.includeAdd(String name,
NodeState after)
Include an added node
|
boolean |
DeleteSubtreeFilter.includeAdd(String name,
NodeState after) |
boolean |
ConstantFilter.includeAdd(String name,
NodeState after) |
boolean |
AddSubtreeFilter.includeAdd(String name,
NodeState after) |
boolean |
ACFilter.includeAdd(String name,
NodeState after) |
boolean |
VisibleFilter.includeDelete(String name,
NodeState before) |
boolean |
UniversalFilter.includeDelete(String name,
NodeState before) |
boolean |
MoveFilter.includeDelete(String name,
NodeState before) |
boolean |
GlobbingPathFilter.includeDelete(String name,
NodeState before) |
boolean |
EventTypeFilter.includeDelete(String name,
NodeState before) |
boolean |
EventFilter.includeDelete(String name,
NodeState before)
Include a deleted node
|
boolean |
DeleteSubtreeFilter.includeDelete(String name,
NodeState before) |
boolean |
ConstantFilter.includeDelete(String name,
NodeState before) |
boolean |
AddSubtreeFilter.includeDelete(String name,
NodeState before) |
boolean |
ACFilter.includeDelete(String name,
NodeState before) |
boolean |
VisibleFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
UniversalFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
MoveFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
GlobbingPathFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
EventTypeFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
EventFilter.includeMove(String sourcePath,
String name,
NodeState moved)
Include a moved node
|
boolean |
DeleteSubtreeFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
ConstantFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
AddSubtreeFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
ACFilter.includeMove(String sourcePath,
String name,
NodeState moved) |
boolean |
VisibleFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
UniversalFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
MoveFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
GlobbingPathFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
EventTypeFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
EventFilter.includeReorder(String destName,
String name,
NodeState reordered)
Include a reordered node
|
boolean |
DeleteSubtreeFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
ConstantFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
AddSubtreeFilter.includeReorder(String destName,
String name,
NodeState reordered) |
boolean |
ACFilter.includeReorder(String destName,
String name,
NodeState reordered) |
NodeState |
UniversalFilter.Selector.select(UniversalFilter filter,
String name,
NodeState before,
NodeState after)
Map a node event.
|
NodeState |
RelativePathSelector.select(UniversalFilter filter,
String name,
NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
FilterBuilder.Condition |
FilterBuilder.universal(UniversalFilter.Selector selector,
Predicate<NodeState> predicate)
A condition that holds when the predicate matches.
|
| Constructor and Description |
|---|
ACFilter(NodeState before,
NodeState after,
PermissionProvider permissionProvider)
Create a new
Filter instance that includes an event when the
observing session has sufficient permissions to read the associated item. |
UniversalFilter(NodeState before,
NodeState after,
UniversalFilter.Selector selector,
Predicate<NodeState> predicate)
Create a new instance of an universal filter rooted at the passed trees.
|
| Constructor and Description |
|---|
UniversalFilter(NodeState before,
NodeState after,
UniversalFilter.Selector selector,
Predicate<NodeState> predicate)
Create a new instance of an universal filter rooted at the passed trees.
|
| Modifier and Type | Method and Description |
|---|---|
static NodeState |
CheckpointAccessor.getCheckpointsRoot(org.apache.jackrabbit.oak.plugins.segment.SegmentNodeStore segmentNodeStore) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
TreeProvider.asNodeState(Tree readOnlyTree) |
| Modifier and Type | Method and Description |
|---|---|
Root |
RootProvider.createReadOnlyRoot(NodeState rootState) |
Tree |
TreeProvider.createReadOnlyTree(NodeState rootState) |
Tree |
TreeProvider.createReadOnlyTree(Tree readOnlyParent,
String childName,
NodeState childState) |
| Modifier and Type | Method and Description |
|---|---|
static Root |
RootFactory.createReadOnlyRoot(NodeState rootState)
Deprecated.
|
static Tree |
TreeFactory.createReadOnlyTree(NodeState rootState)
Deprecated.
|
static Tree |
TreeFactory.createReadOnlyTree(Tree readOnlyParent,
String childName,
NodeState childState)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
TreeProviderService.asNodeState(Tree readOnlyTree) |
NodeState |
AbstractTree.getNodeState() |
| Modifier and Type | Method and Description |
|---|---|
Root |
RootProviderService.createReadOnlyRoot(NodeState rootState) |
Tree |
TreeProviderService.createReadOnlyTree(NodeState rootState) |
Tree |
TreeProviderService.createReadOnlyTree(Tree readOnlyParent,
String childName,
NodeState childState) |
| Constructor and Description |
|---|
ImmutableTree(ImmutableTree.ParentProvider parentProvider,
String name,
NodeState state) |
ImmutableTree(ImmutableTree parent,
String name,
NodeState state) |
ImmutableTree(NodeState rootState) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
VersionHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
VersionHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
ExecutionContext.getBaseState()
Used to evaluate the query (ie.
|
| Constructor and Description |
|---|
ExecutionContext(NodeState baseState,
Root root,
QueryEngineSettings settings,
QueryIndexProvider indexProvider,
PermissionProvider permissionProvider) |
NodeStateNodeTypeInfoProvider(NodeState baseState) |
| Modifier and Type | Method and Description |
|---|---|
abstract void |
SourceImpl.execute(NodeState rootState)
Execute the query.
|
void |
SelectorImpl.execute(NodeState rootState) |
void |
JoinImpl.execute(NodeState rootState) |
abstract String |
SourceImpl.getIndexCostInfo(NodeState rootState)
Get the index cost as a JSON string.
|
String |
SelectorImpl.getIndexCostInfo(NodeState rootState) |
String |
JoinImpl.getIndexCostInfo(NodeState rootState) |
abstract String |
SourceImpl.getPlan(NodeState rootState)
Get the query plan.
|
String |
SelectorImpl.getPlan(NodeState rootState) |
String |
JoinImpl.getPlan(NodeState rootState) |
abstract long |
SourceImpl.getSize(NodeState rootState,
Result.SizePrecision precision,
long max)
Get the size if known.
|
long |
SelectorImpl.getSize(NodeState rootState,
Result.SizePrecision precision,
long max) |
long |
JoinImpl.getSize(NodeState rootState,
Result.SizePrecision precision,
long max) |
| Modifier and Type | Method and Description |
|---|---|
double |
TraversingIndex.getCost(Filter filter,
NodeState rootState) |
String |
TraversingIndex.getPlan(Filter filter,
NodeState rootState) |
boolean |
TraversingIndex.isPotentiallySlow(Filter filter,
NodeState rootState) |
Cursor |
TraversingIndex.query(Filter filter,
NodeState rootState) |
| Modifier and Type | Method and Description |
|---|---|
Validator |
AccessControlValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
VersionablePathHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
PermissionHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
Validator |
MoveAwarePermissionValidator.childNodeAdded(String name,
NodeState after) |
Validator |
MoveAwarePermissionValidator.childNodeDeleted(String name,
NodeState before) |
Validator |
PermissionValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
Validator |
PermissionStoreValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
VersionablePathHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
PermissionHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
ThreeWayConflictHandler.Resolution |
RepMembersConflictHandler.addExistingNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState theirs) |
ThreeWayConflictHandler.Resolution |
RepMembersConflictHandler.changeDeletedNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState base) |
ThreeWayConflictHandler.Resolution |
RepMembersConflictHandler.deleteChangedNode(NodeBuilder parent,
String name,
NodeState theirs,
NodeState base) |
ThreeWayConflictHandler.Resolution |
RepMembersConflictHandler.deleteDeletedNode(NodeBuilder parent,
String name,
NodeState base) |
| Modifier and Type | Class and Description |
|---|---|
class |
SegmentNodeState
A record of type "NODE".
|
| Modifier and Type | Method and Description |
|---|---|
static NodeState |
CheckpointAccessor.getCheckpointsRoot(SegmentNodeStore segmentNodeStore) |
NodeState |
SegmentNodeState.getChildNode(String name) |
NodeState |
Template.getChildNode(String name,
RecordId recordId) |
NodeState |
SegmentNodeStore.getRoot() |
NodeState |
SegmentNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info) |
NodeState |
SegmentNodeStore.rebase(NodeBuilder builder) |
NodeState |
SegmentNodeStore.reset(NodeBuilder builder) |
NodeState |
SegmentNodeStore.retrieve(String checkpoint) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
CancelableDiff.childNodeAdded(String name,
NodeState after) |
boolean |
CancelableDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
CancelableDiff.childNodeDeleted(String name,
NodeState before) |
SegmentNodeState |
Compactor.compact(NodeState state)
Compact a given
state |
SegmentNodeState |
Compactor.compact(NodeState before,
NodeState after,
NodeState onto)
compact the differences between
after and before on top of ont. |
SegmentNodeState |
CheckpointCompactor.compact(NodeState base,
NodeState uncompacted,
NodeState onto)
Compact
uncompacted on top of an optional base. |
boolean |
SegmentNodeState.compareAgainstBaseState(NodeState base,
NodeStateDiff diff) |
static boolean |
SegmentNodeState.fastEquals(NodeState a,
NodeState b)
Indicates whether two
NodeState instances are equal to each
other. |
default RecordId |
SegmentWriter.writeNode(NodeState state)
Write a node state.
|
RecordId |
SegmentWriter.writeNode(NodeState state,
ByteBuffer stableIdBytes)
Write a node state.
|
RecordId |
DefaultSegmentWriter.writeNode(NodeState state,
ByteBuffer stableIdBytes) |
| Modifier and Type | Method and Description |
|---|---|
static NodeState |
Proc.of(Proc.Backend backend) |
| Modifier and Type | Method and Description |
|---|---|
Optional<NodeState> |
Proc.Backend.Commit.getRoot() |
Optional<NodeState> |
Proc.Backend.Record.getRoot() |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
RevisionHistory.HistoryElement.getNode()
Node at given revision
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
Scheduler.getHeadNodeState()
Returns the latest state of the tree.
|
NodeState |
LockBasedScheduler.getHeadNodeState() |
NodeState |
Scheduler.schedule(Commit commit,
Scheduler.SchedulerOption... schedulingOptions)
Schedule a
commit. |
NodeState |
LockBasedScheduler.schedule(Commit commit,
Scheduler.SchedulerOption... schedulingOptions) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
LockBasedScheduler.contentChanged(NodeState root,
CommitInfo info) |
| Modifier and Type | Method and Description |
|---|---|
void |
Trace.run(NodeState node)
Run this trace on the passed
node. |
void |
RandomAccessTrace.run(NodeState root) |
void |
DepthFirstTrace.run(NodeState node) |
void |
BreadthFirstTrace.run(NodeState node) |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
ResetCommitAttributeHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
EmptyHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
EditorHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
CompositeHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
CommitHook.processCommit(NodeState before,
NodeState after,
CommitInfo info)
Validates and/or modifies the given content change before it gets
persisted.
|
| Modifier and Type | Method and Description |
|---|---|
ThreeWayConflictHandler.Resolution |
ThreeWayConflictHandler.addExistingNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState theirs)
The node
ours has been added to parent which conflicts
with node theirs which has been added in the persistence store. |
PartialConflictHandler.Resolution |
PartialConflictHandler.addExistingNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState theirs)
Deprecated.
The node
ours has been added to parent which conflicts
with node theirs which has been added in the persistence store. |
PartialConflictHandler.Resolution |
ConflictHandler.addExistingNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState theirs)
Deprecated.
The node
ours has been added to parent which conflicts
with node theirs which has been added in the persistence store. |
ThreeWayConflictHandler.Resolution |
CompositeConflictHandler.addExistingNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState theirs) |
PartialConflictHandler.Resolution |
PartialConflictHandler.changeDeletedNode(NodeBuilder parent,
String name,
NodeState ours)
Deprecated.
The node
ours has been changed in parent while it was
removed in the persistence store. |
PartialConflictHandler.Resolution |
ConflictHandler.changeDeletedNode(NodeBuilder parent,
String name,
NodeState ours)
Deprecated.
The node
ours has been changed in parent while it was
removed in the persistence store. |
ThreeWayConflictHandler.Resolution |
ThreeWayConflictHandler.changeDeletedNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState base)
The node
ours has been changed in parent while it was
removed in the persistence store. |
ThreeWayConflictHandler.Resolution |
CompositeConflictHandler.changeDeletedNode(NodeBuilder parent,
String name,
NodeState ours,
NodeState base) |
Validator |
VisibleValidator.childNodeAdded(String name,
NodeState after) |
Editor |
VisibleEditor.childNodeAdded(String name,
NodeState after) |
Validator |
Validator.childNodeAdded(String name,
NodeState after)
Validate an added node
|
Validator |
SubtreeValidator.childNodeAdded(String name,
NodeState after) |
Validator |
SubtreeExcludingValidator.childNodeAdded(String name,
NodeState after) |
Editor |
SubtreeEditor.childNodeAdded(String name,
NodeState after) |
Editor |
ProgressNotificationEditor.childNodeAdded(String name,
NodeState after) |
Validator |
FailingValidator.childNodeAdded(String name,
NodeState after) |
boolean |
EditorDiff.childNodeAdded(String name,
NodeState after) |
Editor |
Editor.childNodeAdded(String name,
NodeState after)
Processes an added child node.
|
Validator |
DefaultValidator.childNodeAdded(String name,
NodeState after) |
MoveValidator |
DefaultMoveValidator.childNodeAdded(String name,
NodeState after) |
Editor |
DefaultEditor.childNodeAdded(String name,
NodeState after) |
Editor |
CompositeEditor.childNodeAdded(String name,
NodeState after) |
Validator |
VisibleValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
VisibleEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Validator |
Validator.childNodeChanged(String name,
NodeState before,
NodeState after)
Validate a changed node
|
Validator |
SubtreeValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
Validator |
SubtreeExcludingValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
SubtreeEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
ProgressNotificationEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Validator |
FailingValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
EditorDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
Editor.childNodeChanged(String name,
NodeState before,
NodeState after)
Processes a changed child node.
|
Validator |
DefaultValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
MoveValidator |
DefaultMoveValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
DefaultEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
CompositeEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Validator |
VisibleValidator.childNodeDeleted(String name,
NodeState before) |
Editor |
VisibleEditor.childNodeDeleted(String name,
NodeState before) |
Validator |
Validator.childNodeDeleted(String name,
NodeState before)
Validate a deleted node
|
Validator |
SubtreeValidator.childNodeDeleted(String name,
NodeState before) |
Validator |
SubtreeExcludingValidator.childNodeDeleted(String name,
NodeState before) |
Editor |
SubtreeEditor.childNodeDeleted(String name,
NodeState before) |
Editor |
ProgressNotificationEditor.childNodeDeleted(String name,
NodeState before) |
Validator |
FailingValidator.childNodeDeleted(String name,
NodeState before) |
boolean |
EditorDiff.childNodeDeleted(String name,
NodeState before) |
Editor |
Editor.childNodeDeleted(String name,
NodeState before)
Processes a deleted child node.
|
Validator |
DefaultValidator.childNodeDeleted(String name,
NodeState before) |
MoveValidator |
DefaultMoveValidator.childNodeDeleted(String name,
NodeState before) |
Editor |
DefaultEditor.childNodeDeleted(String name,
NodeState before) |
Editor |
CompositeEditor.childNodeDeleted(String name,
NodeState before) |
void |
Observer.contentChanged(NodeState root,
CommitInfo info)
Observes a content change.
|
void |
EmptyObserver.contentChanged(NodeState root,
CommitInfo info) |
void |
DiffObserver.contentChanged(NodeState root,
CommitInfo info) |
void |
CompositeObserver.contentChanged(NodeState root,
CommitInfo info) |
void |
ChangeDispatcher.contentChanged(NodeState root,
CommitInfo info) |
void |
BackgroundObserver.contentChanged(NodeState root,
CommitInfo info) |
PartialConflictHandler.Resolution |
PartialConflictHandler.deleteChangedNode(NodeBuilder parent,
String name,
NodeState theirs)
Deprecated.
The node
theirs changed in the persistence store while it has been
deleted locally. |
PartialConflictHandler.Resolution |
ConflictHandler.deleteChangedNode(NodeBuilder parent,
String name,
NodeState theirs)
Deprecated.
The node
theirs changed in the persistence store while it has been
deleted locally. |
ThreeWayConflictHandler.Resolution |
ThreeWayConflictHandler.deleteChangedNode(NodeBuilder parent,
String name,
NodeState theirs,
NodeState base)
The node
theirs changed in the persistence store while it has been
deleted locally. |
ThreeWayConflictHandler.Resolution |
CompositeConflictHandler.deleteChangedNode(NodeBuilder parent,
String name,
NodeState theirs,
NodeState base) |
ThreeWayConflictHandler.Resolution |
ThreeWayConflictHandler.deleteDeletedNode(NodeBuilder parent,
String name,
NodeState base)
The node
name has been removed in parent while it was
also removed in the persistence store. |
ThreeWayConflictHandler.Resolution |
CompositeConflictHandler.deleteDeletedNode(NodeBuilder parent,
String name,
NodeState base) |
void |
VisibleValidator.enter(NodeState before,
NodeState after) |
void |
VisibleEditor.enter(NodeState before,
NodeState after) |
void |
ProgressNotificationEditor.enter(NodeState before,
NodeState after) |
void |
FailingValidator.enter(NodeState before,
NodeState after) |
void |
Editor.enter(NodeState before,
NodeState after)
Called before the given before and after states are compared.
|
void |
DefaultValidator.enter(NodeState before,
NodeState after) |
void |
DefaultEditor.enter(NodeState before,
NodeState after) |
void |
CompositeEditor.enter(NodeState before,
NodeState after) |
protected abstract NodeStateDiff |
DiffObserver.getRootDiff(NodeState before,
NodeState after,
CommitInfo info)
Returns the diff handler to be used for the given content change.
|
Editor |
WhiteboardEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
Editor |
ValidatorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
Editor |
EditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info)
Returns an editor for processing changes between the given two states.
|
Editor |
CompositeEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
protected abstract Validator |
ValidatorProvider.getRootValidator(NodeState before,
NodeState after,
CommitInfo info)
Returns a validator for checking the changes between the given
two root states.
|
void |
VisibleValidator.leave(NodeState before,
NodeState after) |
void |
VisibleEditor.leave(NodeState before,
NodeState after) |
void |
ProgressNotificationEditor.leave(NodeState before,
NodeState after) |
void |
FailingValidator.leave(NodeState before,
NodeState after) |
void |
Editor.leave(NodeState before,
NodeState after)
Called after the given before and after states are compared.
|
void |
DefaultValidator.leave(NodeState before,
NodeState after) |
void |
DefaultEditor.leave(NodeState before,
NodeState after) |
void |
CompositeEditor.leave(NodeState before,
NodeState after) |
void |
DefaultMoveValidator.move(String name,
String sourcePath,
NodeState moved) |
static CommitFailedException |
EditorDiff.process(Editor editor,
NodeState before,
NodeState after)
Validates and possibly edits the given subtree by diffing
and recursing through it.
|
NodeState |
ResetCommitAttributeHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
EmptyHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
EditorHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
CompositeHook.processCommit(NodeState before,
NodeState after,
CommitInfo info) |
NodeState |
CommitHook.processCommit(NodeState before,
NodeState after,
CommitInfo info)
Validates and/or modifies the given content change before it gets
persisted.
|
| Constructor and Description |
|---|
ChangeDispatcher(NodeState root)
Create a new instance for dispatching content changes
|
| Modifier and Type | Field and Description |
|---|---|
protected NodeState |
QueryIndex.IndexPlan.Builder.definition |
| Modifier and Type | Method and Description |
|---|---|
NodeState |
QueryIndex.IndexPlan.getDefinition()
The node state with the index definition.
|
| Modifier and Type | Method and Description |
|---|---|
double |
QueryIndex.getCost(Filter filter,
NodeState rootState)
Estimate the worst-case cost to query with the given filter.
|
Iterator<String> |
QueryIndex.NodeAggregator.getParents(NodeState rootState,
String path) |
String |
QueryIndex.getPlan(Filter filter,
NodeState rootState)
Get the query plan for the given filter.
|
String |
QueryIndex.AdvancedQueryIndex.getPlanDescription(QueryIndex.IndexPlan plan,
NodeState root)
Get the query plan description (for logging purposes).
|
List<QueryIndex.IndexPlan> |
QueryIndex.AdvancedQueryIndex.getPlans(Filter filter,
List<QueryIndex.OrderEntry> sortOrder,
NodeState rootState)
Return the possible index plans for the given filter and sort order.
|
List<? extends QueryIndex> |
WhiteboardIndexProvider.getQueryIndexes(NodeState nodeState) |
List<? extends QueryIndex> |
QueryIndexProvider.getQueryIndexes(NodeState nodeState)
Get the currently configured indexes.
|
List<? extends QueryIndex> |
CompositeQueryIndexProvider.getQueryIndexes(NodeState nodeState) |
Cursor |
QueryIndex.query(Filter filter,
NodeState rootState)
Query the index.
|
Cursor |
QueryIndex.AdvancedQueryIndex.query(QueryIndex.IndexPlan plan,
NodeState rootState)
Start a query.
|
QueryIndex.IndexPlan.Builder |
QueryIndex.IndexPlan.Builder.setDefinition(NodeState definition) |
| Modifier and Type | Method and Description |
|---|---|
TreePermission |
TreePermission.getChildPermission(String childName,
NodeState childState)
Retrieve the
TreePermission for the tree identified by the specified
childName and childState, which is a child of the tree
associated with this instanceof TreePermission. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractNodeState
Abstract base class for
NodeState implementations. |
| Modifier and Type | Field and Description |
|---|---|
static Predicate<NodeState> |
NodeState.EXISTS
Predicate that checks the existence of NodeState instances.
|
| Modifier and Type | Method and Description |
|---|---|
NodeState |
NodeStoreBranch.getBase()
Returns the base state of this branch.
|
NodeState |
ReadOnlyBuilder.getBaseState() |
NodeState |
NodeBuilder.getBaseState()
Returns the original base state that this builder is modifying.
|
NodeState |
NodeState.getChildNode(String name)
Returns the named, possibly non-existent, child node.
|
NodeState |
NodeStoreBranch.getHead()
Returns the head state of this branch.
|
static NodeState |
NodeStateUtils.getNode(NodeState node,
String path)
Get a possibly non existing child node of a node.
|
NodeState |
ReadOnlyBuilder.getNodeState() |
NodeState |
NodeBuilder.getNodeState()
Returns an immutable node state that matches the current state of
the builder.
|
NodeState |
ChildNodeEntry.getNodeState()
The child node state
|
NodeState |
ProxyNodeStore.getRoot() |
NodeState |
NodeStore.getRoot()
Returns the latest state of the tree.
|
NodeState |
NodeStoreBranch.merge(CommitHook hook,
CommitInfo info)
Merges the changes in this branch to the main content tree.
|
NodeState |
ProxyNodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info) |
NodeState |
NodeStore.merge(NodeBuilder builder,
CommitHook commitHook,
CommitInfo info)
|
NodeState |
ProxyNodeStore.rebase(NodeBuilder builder) |
NodeState |
NodeStore.rebase(NodeBuilder builder)
|
NodeState |
ProxyNodeStore.reset(NodeBuilder builder) |
NodeState |
NodeStore.reset(NodeBuilder builder)
Reset the passed
builder by throwing away all its changes and
setting its base state to the current root state. |
NodeState |
ProxyNodeStore.retrieve(String checkpoint) |
NodeState |
NodeStore.retrieve(String checkpoint)
Retrieves the root node from a previously created repository checkpoint.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
ConflictAnnotatingRebaseDiff.addExistingNode(NodeBuilder builder,
String name,
NodeState before,
NodeState after) |
protected abstract void |
AbstractRebaseDiff.addExistingNode(NodeBuilder builder,
String name,
NodeState before,
NodeState after)
Called when the node
after was added on the branch but the node
exists already in the trunk. |
void |
ApplyDiff.apply(NodeState target) |
protected void |
ConflictAnnotatingRebaseDiff.changeDeletedNode(NodeBuilder builder,
String name,
NodeState after,
NodeState base) |
protected abstract void |
AbstractRebaseDiff.changeDeletedNode(NodeBuilder builder,
String name,
NodeState after,
NodeState base)
Called when the node
after was changed on the branch but was
deleted already in the trunk. |
boolean |
NodeStateDiff.childNodeAdded(String name,
NodeState after)
Called for all added child nodes.
|
MoveValidator |
MoveValidator.childNodeAdded(String name,
NodeState after) |
Validator |
MoveDetector.childNodeAdded(String name,
NodeState after) |
boolean |
EqualsDiff.childNodeAdded(String name,
NodeState after) |
boolean |
DefaultNodeStateDiff.childNodeAdded(String name,
NodeState after) |
boolean |
ApplyDiff.childNodeAdded(String name,
NodeState after) |
boolean |
AbstractRebaseDiff.childNodeAdded(String name,
NodeState after) |
boolean |
NodeStateDiff.childNodeChanged(String name,
NodeState before,
NodeState after)
Called for all child nodes that may contain changes between the before
and after states.
|
MoveValidator |
MoveValidator.childNodeChanged(String name,
NodeState before,
NodeState after) |
Validator |
MoveDetector.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
EqualsDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
DefaultNodeStateDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
ApplyDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
AbstractRebaseDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
NodeStateDiff.childNodeDeleted(String name,
NodeState before)
Called for all deleted child nodes.
|
MoveValidator |
MoveValidator.childNodeDeleted(String name,
NodeState before) |
Validator |
MoveDetector.childNodeDeleted(String name,
NodeState before) |
boolean |
EqualsDiff.childNodeDeleted(String name,
NodeState before) |
boolean |
DefaultNodeStateDiff.childNodeDeleted(String name,
NodeState before) |
boolean |
ApplyDiff.childNodeDeleted(String name,
NodeState before) |
boolean |
AbstractRebaseDiff.childNodeDeleted(String name,
NodeState before) |
boolean |
NodeState.compareAgainstBaseState(NodeState base,
NodeStateDiff diff)
Compares this node state against the given base state.
|
boolean |
AbstractNodeState.compareAgainstBaseState(NodeState base,
NodeStateDiff diff)
Generic default comparison algorithm that simply walks through the
property and child node lists of the given base state and compares
the entries one by one with corresponding ones (if any) in this state.
|
static boolean |
AbstractNodeState.compareAgainstBaseState(NodeState state,
NodeState base,
NodeStateDiff diff)
Generic default comparison algorithm that simply walks through the
property and child node lists of the given base state and compares
the entries one by one with corresponding ones (if any) in this state.
|
static boolean |
AbstractNodeState.comparePropertiesAgainstBaseState(NodeState state,
NodeState base,
NodeStateDiff diff)
Compares the properties of
base state with this
state. |
protected void |
ConflictAnnotatingRebaseDiff.deleteChangedNode(NodeBuilder builder,
String name,
NodeState before) |
protected abstract void |
AbstractRebaseDiff.deleteChangedNode(NodeBuilder builder,
String name,
NodeState before)
Called when the node
before was deleted in the branch but was
already changed in the trunk. |
protected void |
ConflictAnnotatingRebaseDiff.deleteDeletedNode(NodeBuilder builder,
String name,
NodeState before) |
protected abstract void |
AbstractRebaseDiff.deleteDeletedNode(NodeBuilder builder,
String name,
NodeState before)
Called when the node
before was deleted in the branch but was
already deleted in the trunk. |
void |
MoveDetector.enter(NodeState before,
NodeState after) |
static boolean |
EqualsDiff.equals(NodeState before,
NodeState after)
Diffs the given node states and returns
true if there are no
differences. |
static boolean |
AbstractNodeState.equals(NodeState a,
NodeState b) |
static boolean |
AbstractNodeState.getBoolean(NodeState state,
String name) |
static long |
AbstractNodeState.getLong(NodeState state,
String name) |
static String |
AbstractNodeState.getName(NodeState state,
String name) |
static Iterable<String> |
AbstractNodeState.getNames(NodeState state,
String name) |
static NodeState |
NodeStateUtils.getNode(NodeState node,
String path)
Get a possibly non existing child node of a node.
|
static String |
NodeStateUtils.getPrimaryTypeName(NodeState nodeState) |
static String |
AbstractNodeState.getString(NodeState state,
String name) |
static Iterable<String> |
AbstractNodeState.getStrings(NodeState state,
String name) |
void |
MoveDetector.leave(NodeState before,
NodeState after) |
static boolean |
EqualsDiff.modified(NodeState before,
NodeState after)
Diffs the given node states and returns
true if there are
differences within the properties or direct child nodes. |
void |
MoveValidator.move(String name,
String sourcePath,
NodeState moved)
Called when a moved node has been detected.
|
NodeBuilder |
ReadOnlyBuilder.setChildNode(String name,
NodeState nodeState) |
NodeBuilder |
NodeBuilder.setChildNode(String name,
NodeState nodeState)
Adds or replaces a subtree.
|
void |
NodeStoreBranch.setRoot(NodeState newRoot)
Updates the state of the content tree of this private branch.
|
static String |
NodeStateUtils.toString(NodeState node)
Provides a string representation of the given node state
|
static String |
AbstractNodeState.toString(NodeState state) |
| Constructor and Description |
|---|
ReadOnlyBuilder(NodeState state) |
| Modifier and Type | Method and Description |
|---|---|
protected NodeState |
DescendantsIterator.getNext() |
| Modifier and Type | Method and Description |
|---|---|
static SegmentNodeState |
PersistingDiff.applyDiffOnNodeState(FileStore fileStore,
NodeState before,
NodeState after,
NodeState onto) |
Editor |
SameNameSiblingsEditor.childNodeAdded(String name,
NodeState after) |
boolean |
PersistingDiff.childNodeAdded(String name,
NodeState after) |
boolean |
LoggingEqualsDiff.childNodeAdded(String name,
NodeState after) |
Editor |
SameNameSiblingsEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
PersistingDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
LoggingEqualsDiff.childNodeChanged(String name,
NodeState before,
NodeState after) |
boolean |
PersistingDiff.childNodeDeleted(String name,
NodeState before) |
boolean |
LoggingEqualsDiff.childNodeDeleted(String name,
NodeState before) |
Editor |
SameNameSiblingsEditor.Provider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
void |
SameNameSiblingsEditor.leave(NodeState before,
NodeState after) |
| Constructor and Description |
|---|
DescendantsIterator(NodeState root,
int maxLevel) |
| Modifier and Type | Method and Description |
|---|---|
static CheckpointRetriever.Checkpoint |
CheckpointRetriever.Checkpoint.createFromSegmentNode(String name,
NodeState node) |
| Modifier and Type | Class and Description |
|---|---|
class |
MetadataExposingNodeState |
class |
NameFilteringNodeState |
| Modifier and Type | Method and Description |
|---|---|
protected NodeState |
NameFilteringNodeState.decorateChild(String name,
NodeState delegateChild) |
protected NodeState |
MetadataExposingNodeState.decorateChild(String name,
NodeState delegateChild) |
static NodeState |
MetadataExposingNodeState.wrap(NodeState wrapped) |
static NodeState |
NameFilteringNodeState.wrapRoot(NodeState delegate) |
| Modifier and Type | Method and Description |
|---|---|
protected NodeState |
NameFilteringNodeState.decorateChild(String name,
NodeState delegateChild) |
protected NodeState |
MetadataExposingNodeState.decorateChild(String name,
NodeState delegateChild) |
protected boolean |
NameFilteringNodeState.hideChild(String name,
NodeState delegateChild) |
static NodeState |
MetadataExposingNodeState.wrap(NodeState wrapped) |
static NodeState |
NameFilteringNodeState.wrapRoot(NodeState delegate) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
RestrictionEditor.childNodeAdded(String name,
NodeState after) |
Editor |
AuthorizableFolderEditor.childNodeAdded(String name,
NodeState after) |
Editor |
RestrictionEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
AuthorizableFolderEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
RestrictionEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
Editor |
GroupEditorProvider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
void |
RestrictionEditor.leave(NodeState before,
NodeState after) |
| Modifier and Type | Method and Description |
|---|---|
static NodeState |
VersionHistoryUtil.getVersionStorage(NodeState root) |
| Modifier and Type | Method and Description |
|---|---|
Editor |
VersionablePropertiesEditor.childNodeAdded(String name,
NodeState after) |
Editor |
VersionableEditor.childNodeAdded(String name,
NodeState after) |
Editor |
VersionablePropertiesEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
VersionableEditor.childNodeChanged(String name,
NodeState before,
NodeState after) |
Editor |
VersionableEditor.childNodeDeleted(String name,
NodeState before) |
static void |
VersionCopier.copyVersionStorage(NodeBuilder targetRoot,
NodeState sourceVersionStorage,
NodeBuilder targetVersionStorage,
VersionCopyConfiguration config) |
Editor |
VersionablePropertiesEditor.Provider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder builder,
CommitInfo info) |
Editor |
VersionableEditor.Provider.getRootEditor(NodeState before,
NodeState after,
NodeBuilder rootBuilder,
CommitInfo info) |
static List<String> |
VersionHistoryUtil.getVersionableNodes(NodeState root,
TypePredicate isVersionable,
Calendar olderThan) |
static Calendar |
VersionHistoryUtil.getVersionHistoryLastModified(NodeState versionHistory) |
static NodeState |
VersionHistoryUtil.getVersionStorage(NodeState root) |
void |
VersionableEditor.leave(NodeState before,
NodeState after) |
static NodeBuilder |
VersionHistoryUtil.removeVersions(NodeState root,
List<String> toRemove) |
| Constructor and Description |
|---|
Provider(NodeState sourceRoot,
String workspaceName,
VersionCopyConfiguration config) |
VersionCopier(NodeBuilder targetRoot,
NodeState sourceVersionStorage,
NodeBuilder targetVersionStorage) |
Copyright © 2012–2018 The Apache Software Foundation. All rights reserved.