org.apache.jackrabbit.oak.jcr.observation

Class OakEventFilterImpl

java.lang.Object

org.apache.jackrabbit.api.observation.JackrabbitEventFilter

org.apache.jackrabbit.oak.jcr.observation.filter.OakEventFilter

org.apache.jackrabbit.oak.jcr.observation.OakEventFilterImpl

public class OakEventFilterImpl
extends OakEventFilter

Implements OakEventFilter which is an extension to the JackrabbitEventFilter with features only supported by Oak.

Constructor Summary

Constructors

Constructor and Description
OakEventFilterImpl(JackrabbitEventFilter delegate)

Method Summary

Modifier and Type	Method and Description
OakEventFilterImpl	aggregator(org.apache.jackrabbit.oak.plugins.observation.filter.EventAggregator aggregator)
org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder	builder()
String	getAbsPath()
org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder.Condition	getAdditionalIncludeConditions(Set<String> includePaths)
String[]	getAdditionalPaths()
org.apache.jackrabbit.oak.plugins.observation.filter.EventAggregator	getAggregator()
int	getEventTypes()
String[]	getExcludedPaths()
String[]	getIdentifiers()
boolean	getIsDeep()
String[]	getNodeTypes()
boolean	getNoExternal()
boolean	getNoInternal()
boolean	getNoLocal()
JackrabbitEventFilter	setAbsPath(String absPath)
JackrabbitEventFilter	setAdditionalPaths(String... absPaths)
JackrabbitEventFilter	setEventTypes(int eventTypes)
JackrabbitEventFilter	setExcludedPaths(String... excludedPaths)
JackrabbitEventFilter	setIdentifiers(String[] identifiers)
JackrabbitEventFilter	setIsDeep(boolean isDeep)
JackrabbitEventFilter	setNodeTypes(String[] nodeTypeNames)
JackrabbitEventFilter	setNoExternal(boolean noExternal)
JackrabbitEventFilter	setNoInternal(boolean noInternal)
JackrabbitEventFilter	setNoLocal(boolean noLocal)
OakEventFilter	withApplyNodeTypeOnSelf() This causes the node type filter to be applied on 'this' node instead of the 'parent' node, thus allows to create a filter which listens on adding/removing/etc on nodes of a particular node type (while the default was that the node type was applicable on the parent).
OakEventFilter	withIncludeAncestorsRemove() This causes the registration of independent, additional !deep NODE_REMOVED filter-conditions of all parents of the include paths (both normal and glob).
OakEventFilter	withIncludeGlobPaths(String... globPaths) Adds the provided glob paths to the set of include paths.
OakEventFilter	withIncludeSubtreeOnRemove() This flag causes remove events to be sent for all nodes and properties of an entire subtree (hence use with care!).
OakEventFilter	withNodeTypeAggregate(String[] nodeTypes, String[] relativeGlobPaths) Greedy aggregating filter which upon first (hence greedy) hit of provided nodeTypes checks if the child subtree leading to the actual change matches any of the provided relativeGlobPaths.
org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder.Condition	wrapMainCondition(org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder.Condition mainCondition, org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder filterBuilder, org.apache.jackrabbit.oak.plugins.observation.filter.PermissionProviderFactory permissionProviderFactory)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

OakEventFilterImpl

public OakEventFilterImpl(@Nonnull
                          JackrabbitEventFilter delegate)

Method Detail

getAbsPath

public String getAbsPath()

Overrides:

getAbsPath in class JackrabbitEventFilter

setAbsPath

public JackrabbitEventFilter setAbsPath(String absPath)

Overrides:

setAbsPath in class JackrabbitEventFilter

getAdditionalPaths

public String[] getAdditionalPaths()

Overrides:

getAdditionalPaths in class JackrabbitEventFilter

setAdditionalPaths

public JackrabbitEventFilter setAdditionalPaths(String... absPaths)

Overrides:

setAdditionalPaths in class JackrabbitEventFilter

getEventTypes

public int getEventTypes()

Overrides:

getEventTypes in class JackrabbitEventFilter

setEventTypes

public JackrabbitEventFilter setEventTypes(int eventTypes)

Overrides:

setEventTypes in class JackrabbitEventFilter

getExcludedPaths

public String[] getExcludedPaths()

Overrides:

getExcludedPaths in class JackrabbitEventFilter

setExcludedPaths

public JackrabbitEventFilter setExcludedPaths(String... excludedPaths)

Overrides:

setExcludedPaths in class JackrabbitEventFilter

getIdentifiers

public String[] getIdentifiers()

Overrides:

getIdentifiers in class JackrabbitEventFilter

setIdentifiers

public JackrabbitEventFilter setIdentifiers(String[] identifiers)

Overrides:

setIdentifiers in class JackrabbitEventFilter

getIsDeep

public boolean getIsDeep()

Overrides:

getIsDeep in class JackrabbitEventFilter

setIsDeep

public JackrabbitEventFilter setIsDeep(boolean isDeep)

Overrides:

setIsDeep in class JackrabbitEventFilter

getNodeTypes

public String[] getNodeTypes()

Overrides:

getNodeTypes in class JackrabbitEventFilter

setNodeTypes

public JackrabbitEventFilter setNodeTypes(String[] nodeTypeNames)

Overrides:

setNodeTypes in class JackrabbitEventFilter

getNoExternal

public boolean getNoExternal()

Overrides:

getNoExternal in class JackrabbitEventFilter

setNoExternal

public JackrabbitEventFilter setNoExternal(boolean noExternal)

Overrides:

setNoExternal in class JackrabbitEventFilter

getNoInternal

public boolean getNoInternal()

Overrides:

getNoInternal in class JackrabbitEventFilter

setNoInternal

public JackrabbitEventFilter setNoInternal(boolean noInternal)

Overrides:

setNoInternal in class JackrabbitEventFilter

getNoLocal

public boolean getNoLocal()

Overrides:

getNoLocal in class JackrabbitEventFilter

setNoLocal

public JackrabbitEventFilter setNoLocal(boolean noLocal)

Overrides:

setNoLocal in class JackrabbitEventFilter

withApplyNodeTypeOnSelf

public OakEventFilter withApplyNodeTypeOnSelf()

Description copied from class: OakEventFilter

This causes the node type filter to be applied on 'this' node instead of the 'parent' node, thus allows to create a filter which listens on adding/removing/etc on nodes of a particular node type (while the default was that the node type was applicable on the parent).

Note that this is an 'either/or' thing: either the node type is applied on the parent (default) or on 'self/this' (via this switch) but not both.

Also note that this is independent from the nodeTypeAggregate, and will only be applied to the (main) node types set on this filter, not on the nodeTypeAggregate's node types.

Specified by:

withApplyNodeTypeOnSelf in class OakEventFilter

Returns:

this filter with the filter change applied

withIncludeAncestorsRemove

public OakEventFilter withIncludeAncestorsRemove()

Description copied from class: OakEventFilter

This causes the registration of independent, additional !deep NODE_REMOVED filter-conditions of all parents of the include paths (both normal and glob). (These additional filter-conditions are added in 'OR' mode to the otherwise resulting filter-conditions, thus you can still have an independent deep/!deep flag too)

• include path /a/b/c/d results in additional !deep NODE_REMOVED filters on /a/b/c, on /a/b and on /a
• include path /a/b/** results in additional !deep NODE_REMOVED filter on /a, /a/b and /a/b/**
• include path /a/b/**/*.jsp results in additional deep NODE_REMOVED filter on /a, /a/b and /a/b/**
  Note that this and the above result in the same additional include paths since all this includeAncestorsRemove flag does is include potential ancestors, it doesn't guarantee that there are children matching the given paths (eg it doesn't traverse down)
• additionally for paths with globs (eg /a/b/**/*.jsp) it adds a deep NODE_REMOVED filter explicitly for that path using the same method as withIncludeSubtreeOnRemove does, but only limited to said path. So in this case you get a NODE_REMOVED for all *.jsp that are deleted in a subtree individually

Note that unlike 'normal' include and exclude paths, this variant doesn't apply Oak's NamePathMapper on the ancestors of the registers paths.

Also note that this might disable 'observation prefiltering based on paths' (OAK-4796) on this listener.

Specified by:

withIncludeAncestorsRemove in class OakEventFilter

Returns:

this filter with the filter change applied

wrapMainCondition

public org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder.Condition wrapMainCondition(org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder.Condition mainCondition,
                                                                                                      org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder filterBuilder,
                                                                                                      org.apache.jackrabbit.oak.plugins.observation.filter.PermissionProviderFactory permissionProviderFactory)

withIncludeSubtreeOnRemove

public OakEventFilter withIncludeSubtreeOnRemove()

Description copied from class: OakEventFilter

This flag causes remove events to be sent for all nodes and properties of an entire subtree (hence use with care!).

It is only applied when a parent node is actually removed. For a parent node move this is not applied.

Specified by:

withIncludeSubtreeOnRemove in class OakEventFilter

Returns:

this filter with the filter change applied

withIncludeGlobPaths

public OakEventFilter withIncludeGlobPaths(String... globPaths)

Description copied from class: OakEventFilter

Adds the provided glob paths to the set of include paths.

The definition of a glob path is here

Note that unlike 'normal' include and exclude paths, this variant doesn't apply Oak's NamePathMapper.

This filter property is added in 'or' mode.

Specified by:

withIncludeGlobPaths in class OakEventFilter

Parameters:

globPaths - glob paths that should be added as include path pattern. Note that the NamePathMapper is not applied on these globPaths.

Returns:

this filter with the filter change applied

builder

public org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder builder()

aggregator

public OakEventFilterImpl aggregator(org.apache.jackrabbit.oak.plugins.observation.filter.EventAggregator aggregator)

getAdditionalIncludeConditions

public org.apache.jackrabbit.oak.plugins.observation.filter.FilterBuilder.Condition getAdditionalIncludeConditions(Set<String> includePaths)

getAggregator

public org.apache.jackrabbit.oak.plugins.observation.filter.EventAggregator getAggregator()

withNodeTypeAggregate

public OakEventFilter withNodeTypeAggregate(String[] nodeTypes,
                                            String[] relativeGlobPaths)

Description copied from class: OakEventFilter

Greedy aggregating filter which upon first (hence greedy) hit of provided nodeTypes checks if the child subtree leading to the actual change matches any of the provided relativeGlobPaths.

Note that unlike 'normal' include and exclude paths, this variant doesn't apply Oak's NamePathMapper.

This filter property is added in 'and' mode.

Specified by:

withNodeTypeAggregate in class OakEventFilter

Parameters:

nodeTypes - note that these nodeTypes are not mapped to oak nor validated

relativeGlobPaths - glob paths that are added to the set of include paths. To match the node with the desired node type itself, add an empty String ("") as one of the relativeGlobPaths too. Note that Oak's NamePathMapper is not applied to these relativeGlobPaths.

Returns:

this filter with the filter change applied