Class OakEventFilter

  • Direct Known Subclasses:
    OakEventFilterImpl

    @ConsumerType
    public abstract class OakEventFilter
    extends JackrabbitEventFilter
    Extension of the JackrabbitEventFilter that exposes Oak specific features.

    Usage: OakEventFilter oakFilter = FilterFactory.wrap(jackrabbitFilter); // then call extensions on OakEventFilters observationManager.addEventListener(listener, oakFilter);

    • Constructor Detail

      • OakEventFilter

        public OakEventFilter()
    • Method Detail

      • withApplyNodeTypeOnSelf

        public abstract 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).

        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.

        Returns:
        this filter with the filter change applied
      • withIncludeAncestorsRemove

        public abstract 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). (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.

        Returns:
        this filter with the filter change applied
      • withIncludeSubtreeOnRemove

        public abstract OakEventFilter withIncludeSubtreeOnRemove()
        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.

        Returns:
        this filter with the filter change applied
      • withIncludeGlobPaths

        public abstract OakEventFilter withIncludeGlobPaths​(java.lang.String... globPaths)
        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.

        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
      • withNodeTypeAggregate

        public abstract OakEventFilter withNodeTypeAggregate​(java.lang.String[] nodeTypes,
                                                             java.lang.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.

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

        This filter property is added in 'and' mode.

        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