import com.googlecode.concurrenttrees.radixinverted.InvertedRadixTree; //导入依赖的package包/类
public static void main(String[] args) {
    InvertedRadixTree<Integer> tree = new ConcurrentInvertedRadixTree<Integer>(new DefaultCharArrayNodeFactory());

    tree.put("TEST", 1);
    tree.put("TOAST", 2);
    tree.put("TEAM", 3);

    System.out.println("Tree structure:");
    // PrettyPrintable is a non-public API for testing, prints semi-graphical representations of trees...
    PrettyPrinter.prettyPrint((PrettyPrintable) tree, System.out);

    System.out.println();
    System.out.println("Value for 'TEST' (exact match): " + tree.getValueForExactKey("TEST"));
    System.out.println("Value for 'TOAST' (exact match): " + tree.getValueForExactKey("TOAST"));
    System.out.println();
    System.out.println("Keys contained in 'MY TEAM LIKES TOAST': " + Iterables.toString(tree.getKeysContainedIn("MY TEAM LIKES TOAST")));
    System.out.println("Keys contained in 'MY TEAM LIKES TOASTERS': " + Iterables.toString(tree.getKeysContainedIn("MY TEAM LIKES TOASTERS")));
    System.out.println("Values for keys contained in 'MY TEAM LIKES TOAST': " + Iterables.toString(tree.getValuesForKeysContainedIn("MY TEAM LIKES TOAST")));
    System.out.println("Key-value pairs for keys contained in 'MY TEAM LIKES TOAST': " + Iterables.toString(tree.getKeyValuePairsForKeysContainedIn("MY TEAM LIKES TOAST")));
}
 

import com.googlecode.concurrenttrees.radixinverted.InvertedRadixTree; //导入依赖的package包/类
protected ResultSet<O> retrieveIn(final In<O, A> in, final QueryOptions queryOptions, final InvertedRadixTree<StoredResultSet<O>> tree) {
    // Process the IN query as the union of the EQUAL queries for the values specified by the IN query.
    final Iterable<? extends ResultSet<O>> results = new Iterable<ResultSet<O>>() {
        @Override
        public Iterator<ResultSet<O>> iterator() {
            return new LazyIterator<ResultSet<O>>() {
                final Iterator<A> values = in.getValues().iterator();
                @Override
                protected ResultSet<O> computeNext() {
                    if (values.hasNext()){
                        return retrieveEqual(new Equal<O, A>(in.getAttribute(), values.next()), queryOptions, tree);
                    }else{
                        return endOfData();
                    }
                }
            };
        }
    };
    return deduplicateIfNecessary(results, in, getAttribute(), queryOptions, INDEX_RETRIEVAL_COST);
}
 

import com.googlecode.concurrenttrees.radixinverted.InvertedRadixTree; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public boolean removeAll(ObjectSet<O> objectSet, QueryOptions queryOptions) {
    try {
        boolean modified = false;
        final InvertedRadixTree<StoredResultSet<O>> tree = this.tree;
        for (O object : objectSet) {
            Iterable<A> attributeValues = getAttribute().getValues(object, queryOptions);
            for (A attributeValue : attributeValues) {
                StoredResultSet<O> valueSet = tree.getValueForExactKey(attributeValue);
                if (valueSet == null) {
                    continue;
                }
                modified |= valueSet.remove(object);
                if (valueSet.isEmpty()) {
                    tree.remove(attributeValue);
                }
            }
        }
        return modified;
    }
    finally {
        objectSet.close();
    }
}
 

import com.googlecode.concurrenttrees.radixinverted.InvertedRadixTree; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public boolean addAll(ObjectSet<O> objectSet, QueryOptions queryOptions) {
    try {
        boolean modified = false;
        final InvertedRadixTree<StoredResultSet<O>> tree = this.tree;
        for (O object : objectSet) {
            Iterable<A> attributeValues = getAttribute().getValues(object, queryOptions);
            for (A attributeValue : attributeValues) {

                // Look up StoredResultSet for the value...
                StoredResultSet<O> valueSet = tree.getValueForExactKey(attributeValue);
                if (valueSet == null) {
                    // No StoredResultSet, create and add one...
                    valueSet = createValueSet();
                    StoredResultSet<O> existingValueSet = tree.putIfAbsent(attributeValue, valueSet);
                    if (existingValueSet != null) {
                        // Another thread won race to add new value set, use that one...
                        valueSet = existingValueSet;
                    }
                }
                // Add the object to the StoredResultSet for this value...
                modified |= valueSet.add(object);
            }
        }
        return modified;
    }
    finally {
        objectSet.close();
    }
}