How to use

UniqueEntryStoreStrategy

in

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

private static IndexStoreStrategy newUniqueStrategy(String defaultName) {
  if (INDEX_CONTENT_NODE_NAME.equals(defaultName)) {
    return UNIQUE;
  } else {
    return new UniqueEntryStoreStrategy(defaultName);
  }
}

@Override
public long count(final Filter filter, NodeState root, NodeState indexMeta, Set<String> values, int max) {
  return count(root, indexMeta, 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 static Iterable<String> queryUnique(Filter filter, String indexName, NodeState propIndexRootNode,
                      String propIdxNodeName, Set<String> values) {
  UniqueEntryStoreStrategy s = new UniqueEntryStoreStrategy(propIdxNodeName);
  return s.query(filter, indexName, propIndexRootNode, values);
}

@Before
public void fillIndex() throws Exception {
  
  store = new UniqueEntryStoreStrategy();
  
  indexName = "foo";
  
  NodeState root = EMPTY_NODE;
  indexMeta = root.builder();
  Supplier<NodeBuilder> index = memoize(() -> indexMeta.child(INDEX_CONTENT_NODE_NAME));
  store.update(index, "/some/node1", null, null, EMPTY, newHashSet("key1"));
  store.update(index, "/some/node2", null, null, EMPTY, newHashSet("key2"));
}

/**
 * Search for a given set of values, returning {@linkplain IndexEntry} results
 * 
 * @param filter the filter (can optionally be used for optimized query execution)
 * @param indexName the name of the index (for logging)
 * @param indexMeta the index metadata node (may not be null)
 * @param values values to look for (null to check for property existence)
 * @return an iterator of index entries
 * 
 * @throws UnsupportedOperationException if the operation is not supported
 */
public Iterable<IndexEntry> queryEntries(Filter filter, String indexName, NodeState indexMeta,
    Iterable<String> values) {
  return query0(filter, indexName, indexMeta, values, new HitProducer<IndexEntry>() {
    @Override
    public IndexEntry produce(NodeState indexHit, String pathName) {
      PropertyState s = indexHit.getProperty("entry");
      return new IndexEntry(s.getValue(Type.STRING, 0), pathName);
    }
  });
}

private <T> Iterable<T> query0(Filter filter, String indexName, NodeState indexMeta,
    Iterable<String> values, HitProducer<T> prod) {
  final NodeState index = indexMeta.getChildNode(getIndexNodeName());
  return new Iterable<T>() {
    @Override

public Iterable<IndexEntry> queryAll() {
  return strategy.queryEntries(Filter.EMPTY_FILTER, indexName, indexNode, null);
}

UniqueEntryStoreStrategy s = new UniqueEntryStoreStrategy(INDEX_CONTENT_NODE_NAME,
    (nb) -> nb.setProperty(PROP_CREATED, updateTime));
s.update(ofInstance(indexNode),
    nodePath,
    null,

private static Iterable<String> queryUnique(Filter filter, String indexName, NodeState propIndexRootNode,
                      String propIdxNodeName, Set<String> values) {
  UniqueEntryStoreStrategy s = new UniqueEntryStoreStrategy(propIdxNodeName);
  return s.query(filter, indexName, propIndexRootNode, values);
}

/**
 * Search for a given set of values, returning {@linkplain IndexEntry} results
 * 
 * @param filter the filter (can optionally be used for optimized query execution)
 * @param indexName the name of the index (for logging)
 * @param indexMeta the index metadata node (may not be null)
 * @param values values to look for (null to check for property existence)
 * @return an iterator of index entries
 * 
 * @throws UnsupportedOperationException if the operation is not supported
 */
public Iterable<IndexEntry> queryEntries(Filter filter, String indexName, NodeState indexMeta,
    Iterable<String> values) {
  return query0(filter, indexName, indexMeta, values, new HitProducer<IndexEntry>() {
    @Override
    public IndexEntry produce(NodeState indexHit, String pathName) {
      PropertyState s = indexHit.getProperty("entry");
      return new IndexEntry(s.getValue(Type.STRING, 0), pathName);
    }
  });
}

private <T> Iterable<T> query0(Filter filter, String indexName, NodeState indexMeta,
    Iterable<String> values, HitProducer<T> prod) {
  final NodeState index = indexMeta.getChildNode(getIndexNodeName());
  return new Iterable<T>() {
    @Override

  public Optional<IndexEntry> queryOne(String value) {
    
    Iterable<IndexEntry> results = strategy.queryEntries(Filter.EMPTY_FILTER, indexName, indexNode, Collections.singleton(value));
    if ( !results.iterator().hasNext() ) {
      return Optional.empty();
    }
    
    return Optional.of(results.iterator().next());
  }
}

UniqueEntryStoreStrategy s = new UniqueEntryStoreStrategy(INDEX_CONTENT_NODE_NAME,
    (nb) -> nb.setProperty(PROP_CREATED, updateTime));
s.update(ofInstance(indexNode),
    nodePath,
    null,

private static IndexStoreStrategy newUniqueStrategy(String defaultName) {
  if (INDEX_CONTENT_NODE_NAME.equals(defaultName)) {
    return UNIQUE;
  } else {
    return new UniqueEntryStoreStrategy(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 indexName, 
    final NodeState indexMeta, final Iterable<String> values) {
  return query0(filter, indexName, indexMeta, values, new HitProducer<String>() {
    @Override
    public String produce(NodeState indexHit, String pathName) {
      PropertyState s = indexHit.getProperty("entry");
      if (s.count() <= 1) {
        return s.getValue(Type.STRING, 0);
      } else {
        StringBuilder buff = new StringBuilder();
        for (int i = 0; i < s.count(); i++) {
          if (i > 0) {
            buff.append(", ");
          }
          buff.append(s.getValue(Type.STRING, i));
        }
        return buff.toString();
      }
    }
  });        
}

private <T> Iterable<T> query0(Filter filter, String indexName, NodeState indexMeta,
    Iterable<String> values, HitProducer<T> prod) {
  final NodeState index = indexMeta.getChildNode(getIndexNodeName());
  return new Iterable<T>() {
    @Override

@Test
public void queryEntries_some() {
  Iterable<IndexEntry> hits = store.queryEntries(FilterImpl.newTestInstance(), indexName, indexMeta.getNodeState(), Arrays.asList("key1"));
  
  assertThat(hits, containsInAnyOrder(new IndexEntry("/some/node1", "key1")));
}

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