Use IndexDefinition as the index id instead of the Index name. And so…

…me updates according to pr comments.

.gitignore

@@ -35,4 +35,5 @@
 /underFSStorage/
 dependency-reduced-pom.xml
 target/
+examples/src/main/java/alluxio/examples/LoadGenerator.java
 tests.log*

core/common/src/main/java/alluxio/collections/FieldIndex.java

@@ -22,20 +22,20 @@
  * @param <T> type of objects in this {@link IndexedSet}
  */
 interface FieldIndex<T> {
-  /**
-   * Gets the value of the field that serves as index.
-   *
-   * @param o the instance to get the field value from
-   * @return the field value, which is just an Object
-   */
-  Object getFieldValue(T o);
+//  /**
+//   * Gets the value of the field that serves as index.
+//   *
+//   * @param o the instance to get the field value from
+//   * @return the field value, which is just an Object
+//   */
+//  Object getFieldValue(T o);
 
   /**
    * Puts the an object o to the index.
    *
    * @param o the instance to get the field value from
    */
-  void put(T o);
+  void add(T o);
 
   /**
    * Remove the object o from the index.
@@ -55,17 +55,15 @@ interface FieldIndex<T> {
 
   /**
    * Gets a subset of objects with the specified field value. If there is no object with
-   * the specified field value, a newly created empty set is returned. For non unique index, the
-   * returned set is backed up by an internal set, so changes in internal set will be reflected
-   * in returned set.
+   * the specified field value, a newly created empty set is returned.
    *
    * @param value the field value to be satisfied
    * @return the set of objects or an empty set if no such object exists
    */
   Set<T> getByField(Object value);
 
   /**
-   * Gets the object from the set of objects with the specified unique field value.
+   * Gets an object from the set of objects with the specified unique field value.
    *
    * @param value the field value
    * @return the object or null if there is no such object

core/common/src/main/java/alluxio/collections/IndexDefinition.java

@@ -19,46 +19,20 @@
  *
  * @param <T> type of objects in this {@link IndexedSet}
  */
-public class IndexDefinition<T> {
-
-  /**
-   * An interface abstracting the value of the field that serves as index.
-   *
-   * @param <T> type of objects in this {@link Abstracter}
-   */
-  public interface Abstracter<T> {
-    /**
-     * Gets the value of the field that serves as index.
-     *
-     * @param o the instance to get the field value from
-     * @return the field value, which is just an Object
-     */
-    Object getFieldValue(T o);
-  }
-
-  /** The index name, representing the index in methods of {@link IndexedSet}. */
-  private final String mName;
-
+public abstract class IndexDefinition<T> {
   /** Whether it is a unique index. */
   //TODO(lei): change the mIsUnique to mIndexType enum
   private final boolean mIsUnique;
 
-  /** Abstracts the data field of this index. */
-  private final Abstracter mAbstracter;
-
   /**
    * Constructs a new {@link IndexDefinition} instance.
    *
-   * @param name the name of the field index, used as index id
    * @param isUnique if the index is unique. A unique index is an index where each index value only
    *                 maps toone object; A non-unique index is an index where an index value can map
    *                 to one or more objects.
-   * @param abstracter the interface to abstract the value of the field that serves as index
    */
-  public IndexDefinition(String name, boolean isUnique, Abstracter abstracter) {
+  public IndexDefinition(boolean isUnique) {
     mIsUnique = isUnique;
-    mAbstracter = abstracter;
-    mName = name;
   }
 
   /**
@@ -69,16 +43,10 @@ public boolean isUnique() {
   }
 
   /**
-   * @return the abstracter of the index
-   */
-  public Abstracter getAbstracter() {
-    return mAbstracter;
-  }
-
-  /**
-   * @return the name of the index
+   * Gets the value of the field that serves as index.
+   *
+   * @param o the instance to get the field value from
+   * @return the field value, which is just an Object
    */
-  public String getName() {
-    return mName;
-  }
+  public abstract Object getFieldValue(T o);
 }

core/common/src/main/java/alluxio/collections/IndexedSet.java

@@ -67,14 +67,14 @@
  * First, define the fields to be indexed:
  *
  * <pre>
- *  FieldIndex<Puppy> idIndex = new FieldIndex<Puppy> {
+ *  IndexDefinition<Puppy> idIndex = new IndexDefinition<Puppy>(true) {
  *    {@literal @Override}
  *    Object getFieldValue(Puppy o) {
  *      return o.id();
  *    }
  *  }
  *
- *  FieldIndex<Puppy> nameIndex = new FieldIndex<Puppy> {
+ *  IndexDefinition<Puppy> nameIndex = new IndexDefinition<Puppy>(true) {
  *    {@literal @Override}
  *    Object getFieldValue(Puppy o) {
  *      return o.name();
@@ -111,37 +111,36 @@ public class IndexedSet<T> extends AbstractSet<T> {
   private final ConcurrentHashSet<T> mObjects = new ConcurrentHashSet<>(8, 0.95f, 8);
 
   /**
-   * Map from {@link FieldIndex} to the index. An index is a map from index value to one or a set of
+   * Map from index name to the index. An index is a map from index value to one or a set of
    * objects with that index value. A unique index is an index where each index value only maps to
    * one object. A non-unique index is an index where an index value can map to one or more objects.
    */
-
-  private final Map<String, FieldIndex<T>> mIndices;
+  private final Map<IndexDefinition<T>, FieldIndex<T>> mIndices;
 
   /**
    * Constructs a new {@link IndexedSet} instance with at least one field as the index.
    *
-   * @param field at least one field is needed to index the set of objects
-   * @param otherFields other fields to index the set
+   * @param firstIndexDefinition at least one field is needed to index the set of objects
+   * @param otherIndexDefinitions other index definitions to index the set
    */
   @SafeVarargs
-  public IndexedSet(IndexDefinition<T> field, IndexDefinition<T>... otherFields) {
-    // count the numbers of two index types
-    Iterable<IndexDefinition<T>> fields =
-        Iterables.concat(Arrays.asList(field), Arrays.asList(otherFields));
+  public IndexedSet(IndexDefinition<T> firstIndexDefinition, IndexDefinition<T>...
+      otherIndexDefinitions) {
+    Iterable<IndexDefinition<T>> indexDefinitions =
+        Iterables.concat(Arrays.asList(firstIndexDefinition), Arrays.asList(otherIndexDefinitions));
 
     // initialization
-    Map<String, FieldIndex<T>> indices = new HashMap<String, FieldIndex<T>>();
+    Map<IndexDefinition<T>, FieldIndex<T>> indices = new HashMap<>();
 
-    for (IndexDefinition<T> indexDefinition : fields) {
+    for (IndexDefinition<T> indexDefinition : indexDefinitions) {
       FieldIndex<T> index;
       if (indexDefinition.isUnique()) {
-        index = new UniqueFieldIndex<T>(indexDefinition.getAbstracter());
+        index = new UniqueFieldIndex<T>(indexDefinition);
       } else {
-        index = new NonUniqueFieldIndex<T>(indexDefinition.getAbstracter());
+        index = new NonUniqueFieldIndex<T>(indexDefinition);
       }
 
-      if (indices.put(indexDefinition.getName(), index) != null) {
+      if (indices.put(indexDefinition, index) != null) {
         throw new IllegalStateException("Adding two indices to indexedSet using same name.");
       }
     }
@@ -180,8 +179,8 @@ public boolean add(T object) {
         return false;
       }
 
-      for (Map.Entry<String, FieldIndex<T>> fieldInfo : mIndices.entrySet()) {
-        fieldInfo.getValue().put(object);
+      for (Map.Entry<IndexDefinition<T>, FieldIndex<T>> fieldInfo : mIndices.entrySet()) {
+        fieldInfo.getValue().add(object);
       }
     }
     return true;
@@ -242,38 +241,37 @@ public void remove() {
   /**
    * Whether there is an object with the specified unique index field value in the set.
    *
-   * @param indexName the field index name
+   * @param indexDefinition the field index definition
    * @param value the field value
    * @return true if there is one such object, otherwise false
    */
-  public boolean contains(String indexName, Object value) {
-    FieldIndex<T> index = mIndices.get(indexName);
+  public boolean contains(IndexDefinition<T> indexDefinition, Object value) {
+    FieldIndex<T> index = mIndices.get(indexDefinition);
     return index != null && index.contains(value);
   }
 
   /**
    * Gets a subset of objects with the specified field value. If there is no object with the
-   * specified field value, a newly created empty set is returned. Otherwise, the returned set is
-   * backed up by an internal set, so changes in internal set will be reflected in returned set.
+   * specified field value, a newly created empty set is returned.
    *
-   * @param indexName the field index name
+   * @param indexDefinition the field index definition
    * @param value the field value to be satisfied
    * @return the set of objects or an empty set if no such object exists
    */
-  public Set<T> getByField(String indexName, Object value) {
-    FieldIndex<T> index = mIndices.get(indexName);
+  public Set<T> getByField(IndexDefinition<T> indexDefinition, Object value) {
+    FieldIndex<T> index = mIndices.get(indexDefinition);
     return index == null ? new HashSet<T>() : index.getByField(value);
   }
 
   /**
    * Gets the object from the set of objects with the specified non-unique field value.
    *
-   * @param indexName the field index name
+   * @param indexDefinition the field index definition
    * @param value the field value
    * @return the object or null if there is no such object
    */
-  public T getFirstByField(String indexName, Object value) {
-    FieldIndex<T> index = mIndices.get(indexName);
+  public T getFirstByField(IndexDefinition<T> indexDefinition, Object value) {
+    FieldIndex<T> index = mIndices.get(indexDefinition);
     return index == null ? null : index.getFirst(value);
   }
 
@@ -311,42 +309,35 @@ public boolean remove(Object object) {
    * @param object the object to be removed
    */
   private void removeFromIndices(T object) {
-    for (Map.Entry<String, FieldIndex<T>> fieldInfo : mIndices.entrySet()) {
+    for (Map.Entry<IndexDefinition<T>, FieldIndex<T>> fieldInfo : mIndices.entrySet()) {
       fieldInfo.getValue().remove(object);
     }
   }
 
   /**
    * Removes the object with the specified unique index field value.
    *
-   * @param indexName the field index
+   * @param indexDefinition the field index
    * @param value the field value
    * @return the number of objects removed
    */
-  public int removeByField(String indexName, Object value) {
-    int removed = 0;
-    FieldIndex<T> index = mIndices.get(indexName);
+  public int removeByField(IndexDefinition<T> indexDefinition, Object value) {
+    FieldIndex<T> index = mIndices.get(indexDefinition);
 
     if (index == null) {
       return 0;
-    } else if (index instanceof UniqueFieldIndex) {
-      T toRemove = ((UniqueFieldIndex<T>) index).get(value);
-      if (remove(toRemove)) {
-        removed++;
-      }
-    } else if (index instanceof NonUniqueFieldIndex) {
-      ConcurrentHashSet<T> toRemove = ((NonUniqueFieldIndex<T>) index).get(value);
+    }
 
-      if (toRemove == null) {
-        return 0;
-      }
-      for (T o : toRemove) {
-        if (remove(o)) {
-          removed++;
-        }
+    Set<T> toRemove = index.getByField(value);
+    if (toRemove == null) {
+      return 0;
+    }
+    int removed = 0;
+    for (T o : toRemove) {
+      if (remove(o)) {
+        removed++;
       }
     }
-
     return removed;
   }
 

core/common/src/main/java/alluxio/collections/NonUniqueFieldIndex.java

@@ -23,35 +23,20 @@
  * @param <T> type of objects in this {@link IndexedSet}
  */
 class NonUniqueFieldIndex<T> implements FieldIndex<T> {
-  private final IndexDefinition.Abstracter mAbstracter;
+  private final IndexDefinition<T> mIndexDefinition;
   private ConcurrentHashMap<Object, ConcurrentHashSet<T>> mIndexMap;
 
   /**
    * Constructs a new {@link NonUniqueFieldIndex} instance.
    */
-  public NonUniqueFieldIndex(IndexDefinition.Abstracter abstracter) {
+  public NonUniqueFieldIndex(IndexDefinition<T> indexDefinition) {
     mIndexMap = new ConcurrentHashMap<Object, ConcurrentHashSet<T>>(8, 0.95f, 8);
-    mAbstracter = abstracter;
-  }
-
-  /**
-   * Gets the set of objects with the specified field value - internal function.
-   *
-   * @param value the field value
-   * @return the set of objects with the specified field value
-   */
-  public ConcurrentHashSet<T> get(Object value) {
-    return mIndexMap.get(value);
+    mIndexDefinition = indexDefinition;
   }
 
   @Override
-  public Object getFieldValue(T o) {
-    return mAbstracter.getFieldValue(o);
-  }
-
-  @Override
-  public void put(T object) {
-    Object fieldValue = getFieldValue(object);
+  public void add(T object) {
+    Object fieldValue = mIndexDefinition.getFieldValue(object);
 
     ConcurrentHashSet<T> objSet = mIndexMap.get(fieldValue);
 
@@ -61,20 +46,12 @@ public void put(T object) {
       objSet = mIndexMap.get(fieldValue);
     }
 
-    if (!objSet.addIfAbsent(object)) {
-      // this call can never return false because:
-      // a. the second-level sets in the indices are all
-      // {@link java.util.Set} instances of unbounded space
-      // b. We have already successfully added object on mObjects,
-      // meaning that it cannot be already in any of the sets.
-      // (mObjects is exactly the set-union of all the other second-level sets)
-      throw new IllegalStateException("Indexed Set is in an illegal state");
-    }
+    objSet.add(object);
   }
 
   @Override
   public boolean remove(T object) {
-    Object fieldValue = getFieldValue(object);
+    Object fieldValue = mIndexDefinition.getFieldValue(object);
     ConcurrentHashSet<T> objSet = mIndexMap.get(fieldValue);
     if (objSet != null) {
       return objSet.remove(object);