Index: src/main/java/org/apache/jackrabbit/oak/plugins/index/search/Aggregate.java
===================================================================
--- src/main/java/org/apache/jackrabbit/oak/plugins/index/search/Aggregate.java	(revision 1832658)
+++ src/main/java/org/apache/jackrabbit/oak/plugins/index/search/Aggregate.java	(working copy)
@@ -47,7 +47,7 @@
 import static org.apache.jackrabbit.oak.commons.PathUtils.elements;
 import static org.apache.jackrabbit.oak.commons.PathUtils.getParentPath;
 
-public class Aggregate {
+public class Aggregate<Y> {
 
     public static final String MATCH_ALL = "*";
 
@@ -62,14 +62,14 @@
     private final boolean nodeAggregates;
 
     Aggregate(String nodeTypeName) {
-       this(nodeTypeName, Collections.<Include>emptyList());
+       this(nodeTypeName, Collections.<Include<Y>>emptyList());
     }
 
-    Aggregate(String nodeTypeName, List<? extends Include> includes) {
+    Aggregate(String nodeTypeName, List<? extends Include<Y>> includes) {
         this(nodeTypeName, includes, RECURSIVE_AGGREGATION_LIMIT_DEFAULT);
     }
 
-    Aggregate(String nodeTypeName, List<? extends Include> includes,
+    Aggregate(String nodeTypeName, List<? extends Include<Y>> includes,
               int recursionLimit) {
         this.nodeTypeName = nodeTypeName;
         this.includes = ImmutableList.copyOf(includes);
@@ -78,21 +78,21 @@
         this.nodeAggregates = hasNodeIncludes(includes);
     }
 
-    public List<? extends Include> getIncludes() {
-        return includes;
+    public List<? extends Include<Y>> getIncludes() {
+        return (List<? extends Include<Y>>) includes;
     }
 
     public void collectAggregates(NodeState root, ResultCollector collector) {
         if (matchingType(nodeTypeName, root)) {
-            List<Matcher> matchers = createMatchers();
+            List<Matcher<Y>> matchers = createMatchers();
             collectAggregates(root, matchers, collector);
         }
     }
 
-    public List<Matcher> createMatchers(AggregateRoot root){
-        List<Matcher> matchers = newArrayListWithCapacity(includes.size());
-        for (Include include : includes) {
-            matchers.add(new Matcher(this, include, root));
+    public List<Matcher<Y>> createMatchers(AggregateRoot root){
+        List<Matcher<Y>> matchers = newArrayListWithCapacity(includes.size());
+        for (Include<Y> include : getIncludes()) {
+            matchers.add(new Matcher<Y>(this, include, root));
         }
         return matchers;
     }
@@ -128,7 +128,7 @@
         return false;
     }
 
-    private static void collectAggregates(NodeState nodeState, List<Matcher> matchers,
+    private static <Y> void collectAggregates(NodeState nodeState, List<Matcher<Y>> matchers,
                                           ResultCollector collector) {
         if (hasPatternMatcher(matchers)){
             collectAggregatesForPatternMatchers(nodeState, matchers, collector);
@@ -137,11 +137,11 @@
         }
     }
 
-    private static void collectAggregatesForDirectMatchers(NodeState nodeState, List<Matcher> matchers,
+    private static <Y>void collectAggregatesForDirectMatchers(NodeState nodeState, List<Matcher<Y>> matchers,
                                           ResultCollector collector) {
         Map<String, ChildNodeEntry> children = Maps.newHashMap();
         //Collect potentially matching child nodestates based on matcher name
-        for (Matcher m : matchers){
+        for (Matcher<Y> m : matchers){
             String nodeName = m.getNodeName();
             NodeState child = nodeState.getChildNode(nodeName);
             if (child.exists()){
@@ -151,17 +151,17 @@
         matchChildren(matchers, collector, children.values());
     }
 
-    private static void collectAggregatesForPatternMatchers(NodeState nodeState, List<Matcher> matchers,
+    private static <Y>void collectAggregatesForPatternMatchers(NodeState nodeState, List<Matcher<Y>> matchers,
                                           ResultCollector collector) {
         matchChildren(matchers, collector, nodeState.getChildNodeEntries());
     }
 
-    private static void matchChildren(List<Matcher> matchers, ResultCollector collector,
+    private static <Y> void matchChildren(List<Matcher<Y>> matchers, ResultCollector collector,
                                       Iterable<? extends ChildNodeEntry> children) {
         for (ChildNodeEntry cne : children) {
-            List<Matcher> nextSet = newArrayListWithCapacity(matchers.size());
-            for (Matcher m : matchers) {
-                Matcher result = m.match(cne.getName(), cne.getNodeState());
+            List<Matcher<Y>> nextSet = newArrayListWithCapacity(matchers.size());
+            for (Matcher<Y> m : matchers) {
+                Matcher<Y> result = m.match(cne.getName(), cne.getNodeState());
                 if (result.getStatus() == Matcher.Status.MATCH_FOUND){
                     result.collectResults(collector);
                 }
@@ -176,8 +176,8 @@
         }
     }
 
-    private static boolean hasPatternMatcher(List<Matcher> matchers){
-        for (Matcher m : matchers){
+    private static <Y> boolean hasPatternMatcher(List<Matcher<Y>> matchers){
+        for (Matcher<Y> m : matchers){
             if (m.isPatternBased()){
                 return true;
             }
@@ -185,17 +185,17 @@
         return false;
     }
 
-    private List<Matcher> createMatchers() {
-        List<Matcher> matchers = newArrayListWithCapacity(includes.size());
-        for (Include include : includes) {
-            matchers.add(new Matcher(this, include));
+    private List<Matcher<Y>> createMatchers() {
+        List<Matcher<Y>> matchers = newArrayListWithCapacity(includes.size());
+        for (Include<Y> include : getIncludes()) {
+            matchers.add(new Matcher<Y>(this, include));
         }
         return matchers;
     }
 
-    private static List<NodeInclude> findRelativeNodeIncludes(List<? extends Include> includes) {
+    private static <T> List<NodeInclude> findRelativeNodeIncludes(List<? extends Include<T>> includes) {
         List<NodeInclude> result = newArrayList();
-        for (Include i : includes){
+        for (Include<T> i : includes){
             if (i instanceof NodeInclude){
                 NodeInclude ni = (NodeInclude) i;
                 if (ni.relativeNode){
@@ -206,18 +206,18 @@
         return ImmutableList.copyOf(result);
     }
 
-    private static boolean hasNodeIncludes(List<? extends Include> includes) {
-        return Iterables.any(includes, new Predicate<Include>() {
+    private static <T>boolean hasNodeIncludes(List<? extends Include<T>> includes) {
+        return Iterables.any(includes, new Predicate<Include<T>>() {
             @Override
-            public boolean apply(Include input) {
+            public boolean apply(Include<T> input) {
                 return input instanceof NodeInclude;
             }
         });
     }
 
-    public static interface AggregateMapper {
+    public static interface AggregateMapper<Y> {
         @CheckForNull
-        Aggregate getAggregate(String nodeTypeName);
+        Aggregate<Y> getAggregate(String nodeTypeName);
     }
 
     //~-----------------------------------------------------< Includes >
@@ -256,7 +256,7 @@
         public abstract boolean aggregatesProperty(String name);
 
         @CheckForNull
-        public Aggregate getAggregate(NodeState matchedNodeState) {
+        public <Y extends T> Aggregate<Y> getAggregate(NodeState matchedNodeState) {
             return null;
         }
 
@@ -276,13 +276,13 @@
         final String primaryType;
         final boolean relativeNode;
         private final String pattern;
-        private final AggregateMapper aggMapper;
+        private final AggregateMapper<NodeInclude> aggMapper;
 
-        public NodeInclude(AggregateMapper mapper, String pattern) {
+        public NodeInclude(AggregateMapper<NodeInclude> mapper, String pattern) {
             this(mapper, null, pattern, false);
         }
 
-        public NodeInclude(AggregateMapper mapper, String primaryType, String pattern, boolean relativeNode) {
+        public NodeInclude(AggregateMapper<NodeInclude> mapper, String primaryType, String pattern, boolean relativeNode) {
             super(pattern);
             this.pattern = pattern;
             this.primaryType = primaryType;
@@ -320,9 +320,9 @@
         }
 
         @Override
-        public Aggregate getAggregate(NodeState matchedNodeState) {
+        public Aggregate<NodeInclude> getAggregate(NodeState matchedNodeState) {
             //Check agg defn for primaryType first
-            Aggregate agg = aggMapper.getAggregate(ConfigUtil.getPrimaryTypeName(matchedNodeState));
+            Aggregate<NodeInclude> agg = aggMapper.getAggregate(ConfigUtil.getPrimaryTypeName(matchedNodeState));
 
             //If not found then look for defn for mixins
             if (agg == null) {
@@ -473,15 +473,15 @@
         String getPath();
     }
 
-    public static class Matcher {
+    public static class Matcher<Y> {
         public enum Status {CONTINUE, MATCH_FOUND, FAIL}
 
-        private static class RootState {
+        private static class RootState<X> {
             final AggregateRoot root;
-            final Aggregate rootAggregate;
-            final Include rootInclude;
+            final Aggregate<X> rootAggregate;
+            final Include<X> rootInclude;
 
-            private RootState(AggregateRoot root, Aggregate rootAggregate, Include rootInclude) {
+            private RootState(AggregateRoot root, Aggregate<X> rootAggregate, Include<X> rootInclude) {
                 this.root = root;
                 this.rootAggregate = rootAggregate;
                 this.rootInclude = rootInclude;
@@ -488,7 +488,7 @@
             }
         }
 
-        private final RootState rootState;
+        private final RootState<Y> rootState;
         private final Include currentInclude;
         /**
          * Current depth in the include pattern.
@@ -500,12 +500,12 @@
 
         private final List<String> aggregateStack;
 
-        public Matcher(Aggregate aggregate, Include currentInclude) {
+        public Matcher(Aggregate<Y> aggregate, Include currentInclude) {
             this(aggregate, currentInclude, null);
         }
 
-        public Matcher(Aggregate aggregate, Include include, AggregateRoot root) {
-            this.rootState = new RootState(root, aggregate, include);
+        public Matcher(Aggregate<Y> aggregate, Include include, AggregateRoot root) {
+            this.rootState = new RootState<Y>(root, aggregate, include);
             this.depth = 0;
             this.currentInclude = include;
             this.status = Status.CONTINUE;
@@ -514,7 +514,7 @@
             this.aggregateStack = Collections.emptyList();
         }
 
-        private Matcher(Matcher m, Status status, int depth) {
+        private Matcher(Matcher<Y> m, Status status, int depth) {
             checkArgument(status == Status.FAIL);
             this.rootState = m.rootState;
             this.depth = depth;
@@ -525,7 +525,7 @@
             this.aggregateStack = m.aggregateStack;
         }
 
-        private Matcher(Matcher m, Status status, int depth,
+        private Matcher(Matcher<Y> m, Status status, int depth,
                         NodeState matchedNodeState, String currentPath) {
             checkArgument(status != Status.FAIL);
             this.rootState = m.rootState;
@@ -537,7 +537,7 @@
             this.aggregateStack = m.aggregateStack;
         }
 
-        private Matcher(Matcher m, Include i, String currentPath) {
+        private Matcher(Matcher<Y> m, Include i, String currentPath) {
             checkArgument(m.status == Status.MATCH_FOUND);
             this.rootState = m.rootState;
             this.depth = 0;
@@ -563,24 +563,24 @@
             return currentInclude.getElementNameIfNotAPattern(depth);
         }
 
-        public Matcher match(String name, NodeState nodeState) {
+        public Matcher<Y> match(String name, NodeState nodeState) {
             boolean result = currentInclude.match(name, nodeState, depth);
             if (result){
                 if (hasMore()){
-                    return new Matcher(this, Status.CONTINUE, depth, nodeState, path(name));
+                    return new Matcher<Y>(this, Status.CONTINUE, depth, nodeState, path(name));
                 } else {
-                    return new Matcher(this, Status.MATCH_FOUND, depth, nodeState, path(name));
+                    return new Matcher<Y>(this, Status.MATCH_FOUND, depth, nodeState, path(name));
                 }
             } else {
-                return new Matcher(this, Status.FAIL, depth);
+                return new Matcher<Y>(this, Status.FAIL, depth);
             }
         }
 
-        public Collection<Matcher> nextSet() {
+        public Collection<Matcher<Y>> nextSet() {
             checkArgument(status != Status.FAIL);
 
             if (status == Status.MATCH_FOUND){
-                Aggregate nextAgg = currentInclude.getAggregate(matchedNodeState);
+                Aggregate<Y> nextAgg = currentInclude.getAggregate(matchedNodeState);
                 if (nextAgg != null){
                     int recursionLevel = aggregateStack.size() + 1;
 
@@ -588,9 +588,9 @@
                         return Collections.emptyList();
                     }
 
-                    List<Matcher> result = Lists.newArrayListWithCapacity(nextAgg.includes.size());
+                    List<Matcher<Y>> result = Lists.newArrayListWithCapacity(nextAgg.includes.size());
                     for (Include i : nextAgg.includes){
-                        result.add(new Matcher(this,  i, currentPath));
+                        result.add(new Matcher<Y>(this,  i, currentPath));
                     }
                     return result;
                 }
@@ -597,7 +597,7 @@
                 return Collections.emptyList();
             }
 
-            return Collections.singleton(new Matcher(this, status, depth + 1,
+            return Collections.singleton(new Matcher<Y>(this, status, depth + 1,
                     null, currentPath));
         }