How to use

ContentMirrorStoreStrategy

in

org.apache.jackrabbit.oak.plugins.index.property.strategy

private static IndexStoreStrategy newMirrorStrategy(String defaultName) {
  if (INDEX_CONTENT_NODE_NAME.equals(defaultName)) {
    return MIRROR;
  } else {
    return new ContentMirrorStoreStrategy(defaultName);
  }
}

@Override
public Iterable<String> query(final Filter filter, final String name,
    final NodeState indexMeta, final Iterable<String> values) {
  return query(filter, name, indexMeta, this.indexName, values);
}

@Override
public long count(NodeState root, NodeState indexMeta, Set<String> values, int max) {
  return count(null, root, indexMeta, this.indexName, values, max);
}

@Override
public void update(
    Supplier<NodeBuilder> index, String path,
    @Nullable final String indexName,
    @Nullable final NodeBuilder indexMeta,
    Set<String> beforeKeys, Set<String> afterKeys) {
  for (String key : beforeKeys) {
    remove(index.get(), key, path);
  }
  for (String key : afterKeys) {
    insert(index.get(), key, path);
  }
}

  private Iterable<String> queryBucket(Filter filter, String indexName, NodeState propIndexNode,
                     String bucketPropName, Set<String> values) {
    String bucketName = propIndexNode.getString(bucketPropName);
    if (bucketName == null) {
      return Collections.emptyList();
    }

    NodeState bucket = propIndexNode.getChildNode(bucketName);
    if (bucket.getChildNodeCount(1) == 0) {
      return Collections.emptyList();
    }

    ContentMirrorStoreStrategy s = new ContentMirrorStoreStrategy(bucketName, pathPrefix, prependPathPrefix);
    return s.query(filter, indexName, propIndexNode, bucketName, values);
  }
}

  uniquenessConstraintValidator.add(propertyRelativePath, afterKeys);
} else {
  ContentMirrorStoreStrategy s = new ContentMirrorStoreStrategy();
  s.update(ofInstance(indexNode),
      nodePath,
      null,

private void insert(NodeBuilder index, String key, String value) {
  ApproximateCounter.adjustCountSync(index, 1);
  // NodeBuilder builder = index.child(key);
  NodeBuilder builder = fetchKeyNode(index, key);
  ApproximateCounter.adjustCountSync(builder, 1);
  for (String name : PathUtils.elements(value)) {
    builder = builder.child(name);
  }
  builder.setProperty("match", true);
}

  @Override
  public Iterator<String> iterator() {
    PathIterator it = new PathIterator(filter, indexName, pathPrefix, prependPathPrefix);
    if (values == null) {
      it.setPathContainsValue(true);
      it.enqueue(getChildNodeEntries(index).iterator());
    } else {
      for (String p : values) {
        NodeState property = index.getChildNode(p);
        if (property.exists()) {
          // we have an entry for this value, so use it
          it.enqueue(Iterators.singletonIterator(
              new MemoryChildNodeEntry("", property)));
        }
      }
    }
    return it;
  }
};

private void remove(NodeBuilder index, String key, String value) {
  ApproximateCounter.adjustCountSync(index, -1);
  NodeBuilder builder = index.getChildNode(key);
  if (builder.exists()) {
    ApproximateCounter.adjustCountSync(builder, -1);
    // Collect all builders along the given path
    Deque<NodeBuilder> builders = newArrayDeque();
    builders.addFirst(builder);
    // Descend to the correct location in the index tree
    for (String name : PathUtils.elements(value)) {
      builder = builder.getChildNode(name);
      builders.addFirst(builder);
    }
    // Drop the match value,  if present
    if (builder.exists()) {
      builder.removeProperty("match");
    }
    // Prune all index nodes that are no longer needed
    prune(index, builders, key);
  }
}

  private Iterable<String> queryBucket(Filter filter, String indexName, NodeState propIndexNode,
                     String bucketPropName, Set<String> values) {
    String bucketName = propIndexNode.getString(bucketPropName);
    if (bucketName == null) {
      return Collections.emptyList();
    }

    NodeState bucket = propIndexNode.getChildNode(bucketName);
    if (bucket.getChildNodeCount(1) == 0) {
      return Collections.emptyList();
    }

    ContentMirrorStoreStrategy s = new ContentMirrorStoreStrategy(bucketName, pathPrefix, prependPathPrefix);
    return s.query(filter, indexName, propIndexNode, bucketName, values);
  }
}

  uniquenessConstraintValidator.add(propertyRelativePath, afterKeys);
} else {
  ContentMirrorStoreStrategy s = new ContentMirrorStoreStrategy();
  s.update(ofInstance(indexNode),
      nodePath,
      null,

@Override
public void update(
    Supplier<NodeBuilder> index, String path,
    @Nullable final String indexName,
    @Nullable final NodeBuilder indexMeta,
    Set<String> beforeKeys, Set<String> afterKeys) {
  for (String key : beforeKeys) {
    remove(index.get(), key, path);
  }
  for (String key : afterKeys) {
    insert(index.get(), key, path);
  }
}

private void insert(NodeBuilder index, String key, String value) {
  ApproximateCounter.adjustCountSync(index, 1);
  // NodeBuilder builder = index.child(key);
  NodeBuilder builder = fetchKeyNode(index, key);
  ApproximateCounter.adjustCountSync(builder, 1);
  for (String name : PathUtils.elements(value)) {
    builder = builder.child(name);
  }
  builder.setProperty("match", true);
}

  @Override
  public Iterator<String> iterator() {
    PathIterator it = new PathIterator(filter, indexName, pathPrefix, prependPathPrefix);
    if (values == null) {
      it.setPathContainsValue(true);
      it.enqueue(getChildNodeEntries(index).iterator());
    } else {
      for (String p : values) {
        NodeState property = index.getChildNode(p);
        if (property.exists()) {
          // we have an entry for this value, so use it
          it.enqueue(Iterators.singletonIterator(
              new MemoryChildNodeEntry("", property)));
        }
      }
    }
    return it;
  }
};

private void remove(NodeBuilder index, String key, String value) {
  ApproximateCounter.adjustCountSync(index, -1);
  NodeBuilder builder = index.getChildNode(key);
  if (builder.exists()) {
    ApproximateCounter.adjustCountSync(builder, -1);
    // Collect all builders along the given path
    Deque<NodeBuilder> builders = newArrayDeque();
    builders.addFirst(builder);
    // Descend to the correct location in the index tree
    for (String name : PathUtils.elements(value)) {
      builder = builder.getChildNode(name);
      builders.addFirst(builder);
    }
    // Drop the match value,  if present
    if (builder.exists()) {
      builder.removeProperty("match");
    }
    // Prune all index nodes that are no longer needed
    prune(index, builders, key);
  }
}

private static IndexStoreStrategy newMirrorStrategy(String defaultName) {
  if (INDEX_CONTENT_NODE_NAME.equals(defaultName)) {
    return MIRROR;
  } else {
    return new ContentMirrorStoreStrategy(defaultName);
  }
}

@Override
public void update(
    Supplier<NodeBuilder> index, String path,
    @Nullable final String indexName,
    @Nullable final NodeBuilder indexMeta,
    Set<String> beforeKeys, Set<String> afterKeys) {
  for (String key : beforeKeys) {
    remove(index.get(), key, path);
  }
  for (String key : afterKeys) {
    insert(index.get(), key, path);
  }
}

@Override
public Iterable<String> query(final Filter filter, final String name,
    final NodeState indexMeta, final Iterable<String> values) {
  return query(filter, name, indexMeta, this.indexName, values);
}

@Override
public long count(final Filter filter, NodeState root, NodeState indexMeta, Set<String> values, int max) {
  return count(filter, root, indexMeta, this.indexName, values, max);
}

private void insert(NodeBuilder index, String key, String value) {
  ApproximateCounter.adjustCountSync(index, 1);
  // NodeBuilder builder = index.child(key);
  NodeBuilder builder = fetchKeyNode(index, key);
  ApproximateCounter.adjustCountSync(builder, 1);
  for (String name : PathUtils.elements(value)) {
    builder = builder.child(name);
  }
  builder.setProperty("match", true);
}