@Override
    public void accept(final Val[] values) {
        final int[] groupSizeByDepth = compiledDepths.getGroupSizeByDepth();
        final boolean[][] groupIndicesByDepth = compiledDepths.getGroupIndicesByDepth();
        final boolean[][] valueIndicesByDepth = compiledDepths.getValueIndicesByDepth();

        Key key = Key.ROOT_KEY;
        Key parentKey = key;
        for (int depth = 0; depth < groupIndicesByDepth.length; depth++) {
            final StoredValues storedValues = valueReferenceIndex.createStoredValues();
            final int groupSize = groupSizeByDepth[depth];
            final boolean[] groupIndices = groupIndicesByDepth[depth];
            final boolean[] valueIndices = valueIndicesByDepth[depth];

            Val[] groupValues = Val.emptyArray();
            if (groupSize > 0) {
                groupValues = new Val[groupSize];
            }

            int groupIndex = 0;
            for (int columnIndex = 0; columnIndex < compiledColumnsArray.length; columnIndex++) {
                final CompiledColumn compiledColumn = compiledColumnsArray[columnIndex];

                final Generator generator = compiledColumn.getGenerator();
                if (generator != null) {
                    final ValCache valCache = new ValCache(generator);
                    Val value;

                    // ALL VALUE FILTERING IS DONE IN LMDB SO NOT NEEDED HERE.
//                    // If this is the first level then check if we should filter out this data.
//                    if (depth == 0) {
//                        final Optional<Predicate<String>> optionalCompiledFilter = compiledColumn.getCompiledFilter();
//                        if (optionalCompiledFilter.isPresent()) {
//                            // If we are filtering then we need to evaluate this field
//                            // now so that we can filter the resultant value.
//                            value = valCache.getVal(values, storedValues);
//
//                            if (value != null && !optionalCompiledFilter.get().test(value.toString())) {
//                                // We want to exclude this item so get out of this method ASAP.
//                                return;
//                            }
//                        }
//                    }

                    // If we are grouping at this level then evaluate the expression and add to the group values.
                    if (groupIndices[columnIndex]) {
                        // If we haven't already created the generator then do so now.
                        value = valCache.getVal(values, storedValues);
                        groupValues[groupIndex++] = value;
                    }

                    // If we need a value at this level then evaluate the expression and add the value.
                    if (valueIndices[columnIndex]) {
                        // If we haven't already created the generator then do so now.
                        value = valCache.getVal(values, storedValues);
                    }
                }
            }

            // Trim group values.
            if (groupIndex < groupSize) {
                groupValues = Arrays.copyOf(groupValues, groupIndex);
            }

            if (depth <= compiledDepths.getMaxGroupDepth()) {
                // This is a grouped item.
                key = key.resolve(0, groupValues);

            } else {
                // This item will not be grouped.
                key = key.resolve(0, keyFactory.getUniqueId());
            }

            addToChildMap(depth, parentKey, key, storedValues);
            parentKey = key;
        }
    }
Add some values to the data store.

@param values The values to add to the store.
stroom-query/stroom-query-common/src/main/java/stroom/query/common/v2/MapDataStore.java