Wording.

Author: run2000

src/net/njcull/collections/Collectors.java

@@ -7,7 +7,7 @@
 
 /**
  * Implementations of stream {@link Collector}s for the maps and sets in this
- * package. Variations include map versus bimap, and various sorting options
+ * package. Variations include map versus bi-map, and various sorting options
  * for those sets and maps that are ordered.
  *
  * @author run2000
@@ -106,16 +106,16 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableArrayMap}, created as a bimap, in encounter order.
+     * new {@code ImmutableArrayMap}, created as a bi-map, in encounter order.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
      * @param <K> the type of keys in the resulting map
      * @param <V> the type of values in the resulting map
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableArrayMap}, created as a bimap, in encounter order
+     * into a {@code ImmutableArrayMap}, created as a bi-map, in encounter order
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableArrayMap<K,V>> toImmutableArrayBiMap() {
         return Collector.<Map.Entry<? extends K,? extends V>, ImmutableArrayMapBuilder<K,V>, ImmutableArrayMap<K,V>>of(
@@ -144,17 +144,17 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableHashedArrayMap}, created as a bimap, in
+     * new {@code ImmutableHashedArrayMap}, created as a bi-map, in
      * encounter order.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
      * @param <K> the type of keys in the resulting map
      * @param <V> the type of values in the resulting map
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableHashedArrayMap}, created as a bimap, in
+     * into a {@code ImmutableHashedArrayMap}, created as a bi-map, in
      * encounter order
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableHashedArrayMap<K,V>> toImmutableHashedArrayBiMap() {
@@ -254,18 +254,18 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableSortedArrayMap}, created as a bimap, with elements
+     * new {@code ImmutableSortedArrayMap}, created as a bi-map, with elements
      * ordered by their natural order.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
      * @param <K> the type of keys in the resulting map
      * @param <V> the type of values in the resulting map
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableSortedArrayMap}, with elements ordered by their
-     * natural order
+     * into a {@code ImmutableSortedArrayMap}, created as a bi-map, with
+     * elements ordered by their natural order
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableSortedArrayMap<K,V>> toImmutableSortedArrayBiMap() {
         return Collector.<Map.Entry<? extends K,? extends V>, ImmutableSortedArrayMapBuilder<K,V>, ImmutableSortedArrayMap<K,V>>of(
@@ -277,10 +277,10 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableSortedArrayMap}, created as a bimap, with keys
+     * new {@code ImmutableSortedArrayMap}, created as a bi-map, with keys
      * ordered by the given {@code Comparator}.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
@@ -289,8 +289,8 @@ private Collectors() {
      * @param keyCmp a comparator for ordering keys, or {@code null} to indicate
      * natural key ordering
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableSortedArrayMap}, with keys ordered by the given
-     * comparator
+     * into a {@code ImmutableSortedArrayMap}, created as a bi-map, with keys
+     * ordered by the given comparator
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableSortedArrayMap<K,V>> toImmutableSortedArrayBiMapComparingKeys(
             final Comparator<? super K> keyCmp) {
@@ -303,10 +303,10 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableSortedArrayMap}, created as a bimap, with values
+     * new {@code ImmutableSortedArrayMap}, created as a bi-map, with values
      * ordered by the given {@code Comparator}.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
@@ -315,8 +315,8 @@ private Collectors() {
      * @param valCmp a comparator for ordering values, or {@code null}
      * to indicate natural value ordering
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableSortedArrayMap}, with values ordered by the given
-     * comparator
+     * into a {@code ImmutableSortedArrayMap}, created as a bi-map, with values
+     * ordered by the given comparator
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableSortedArrayMap<K,V>> toImmutableSortedArrayBiMapComparingValues(
             final Comparator<? super V> valCmp) {
@@ -329,10 +329,10 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableSortedArrayMap}, created as a bimap, with keys
+     * new {@code ImmutableSortedArrayMap}, created as a bi-map, with keys
      * and values ordered by the given {@code Comparator}s.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
@@ -343,8 +343,8 @@ private Collectors() {
      * @param valCmp a comparator for ordering values, or {@code null}
      * to indicate natural value ordering
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableSortedArrayMap}, with keys and values ordered by
-     * the given comparators
+     * into a {@code ImmutableSortedArrayMap}, created as a bi-map, with keys
+     * and values ordered by the given comparators
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableSortedArrayMap<K,V>> toImmutableSortedArrayBiMapComparingKeysAndValues(
             final Comparator<? super K> keyCmp, final Comparator<? super V> valCmp) {
@@ -398,18 +398,18 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableUniSortedArrayMap}, created as a bimap, with keys
+     * new {@code ImmutableUniSortedArrayMap}, created as a bi-map, with keys
      * ordered by their natural order.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
      * @param <K> the type of keys in the resulting map
      * @param <V> the type of values in the resulting map
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableSortedArrayMap}, with keys ordered by their
-     * natural order
+     * into a {@code ImmutableSortedArrayMap}, created as a bi-map, with keys
+     * ordered by their natural order
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableUniSortedArrayMap<K,V>> toImmutableUniSortedArrayBiMap() {
         return Collector.<Map.Entry<? extends K,? extends V>, ImmutableUniSortedArrayMapBuilder<K,V>, ImmutableUniSortedArrayMap<K,V>>of(
@@ -421,10 +421,10 @@ private Collectors() {
 
     /**
      * Returns a {@code Collector} that accumulates the input elements into a
-     * new {@code ImmutableUniSortedArrayMap}, created as a bimap, with keys
+     * new {@code ImmutableUniSortedArrayMap}, created as a bi-map, with keys
      * ordered by the given {@code Comparator}.
      * <p>
-     * A bimap is a map where both keys and values are unique. Any given key
+     * A bi-map is a map where both keys and values are unique. Any given key
      * can be mapped "forwards" to a single value; any given value can be
      * mapped "backwards" to a single key.
      *
@@ -433,8 +433,8 @@ private Collectors() {
      * @param keyCmp a comparator for ordering keys, or {@code null} to indicate
      * natural key ordering
      * @return a {@code Collector} which collects all the input keys and values
-     * into a {@code ImmutableSortedArrayMap}, with keys ordered by the given
-     * comparator
+     * into a {@code ImmutableSortedArrayMap}, created as a bi-map, with keys
+     * ordered by the given comparator
      */
     public static <K,V> Collector<Map.Entry<? extends K,? extends V>, ?, ImmutableUniSortedArrayMap<K,V>> toImmutableUniSortedArrayBiMapComparing(
             final Comparator<? super K> keyCmp) {

src/net/njcull/collections/ImmutableArrayMapBuilder.java

@@ -31,11 +31,11 @@ public static <K,V> ImmutableArrayMapBuilder<K,V> newMap() {
     }
 
     /**
-     * Create a new builder instance that builds a new immutable bimap.
+     * Create a new builder instance that builds a new immutable bi-map.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
-     * @return a new builder for building a new bimap
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableArrayMapBuilder<K,V> newBiMap() {
         ImmutableArrayMapBuilder<K,V> builder = new ImmutableArrayMapBuilder<>();

src/net/njcull/collections/ImmutableHashedArrayMapBuilder.java

@@ -36,11 +36,11 @@ public static <K,V> ImmutableHashedArrayMapBuilder<K,V> newMap() {
     }
 
     /**
-     * Create a new builder instance that builds a new immutable hashed bimap.
+     * Create a new builder instance that builds a new immutable hashed bi-map.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
-     * @return a new builder for building a new bimap
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableHashedArrayMapBuilder<K,V> newBiMap() {
         ImmutableHashedArrayMapBuilder<K,V> builder = new ImmutableHashedArrayMapBuilder<>();

src/net/njcull/collections/ImmutableSortedArrayMapBuilder.java

@@ -35,11 +35,11 @@ public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newMap() {
     }
 
     /**
-     * Create a new builder instance that builds a new immutable sorted bimap.
+     * Create a new builder instance that builds a new immutable sorted bi-map.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
-     * @return a new builder for building a new bimap
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newBiMap() {
         ImmutableSortedArrayMapBuilder<K,V> builder = new ImmutableSortedArrayMapBuilder<>();
@@ -61,13 +61,13 @@ public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newMapComparingKeys(Comp
     }
 
     /**
-     * Create a new builder instance that builds a new immutable sorted bimap
+     * Create a new builder instance that builds a new immutable sorted bi-map
      * using the supplied comparator for sorting the keys.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
      * @param cmp the key comparator for sorting the map
-     * @return a new builder for building a new map
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newBiMapComparingKeys(Comparator<? super K> cmp) {
         ImmutableSortedArrayMapBuilder<K,V> builder = new ImmutableSortedArrayMapBuilder<>();
@@ -89,13 +89,13 @@ public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newMapComparingValues(Co
     }
 
     /**
-     * Create a new builder instance that builds a new immutable sorted bimap
+     * Create a new builder instance that builds a new immutable sorted bi-map
      * using the supplied comparator for sorting the values.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
      * @param cmp the values comparator for sorting the map
-     * @return a new builder for building a new map
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newBiMapComparingValues(Comparator<? super V> cmp) {
         ImmutableSortedArrayMapBuilder<K,V> builder = new ImmutableSortedArrayMapBuilder<>();
@@ -119,14 +119,14 @@ public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newMapComparing(Comparat
     }
 
     /**
-     * Create a new builder instance that builds a new immutable sorted bimap
+     * Create a new builder instance that builds a new immutable sorted bi-map
      * using the supplied comparators for sorting the keys and values.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
      * @param keyCmp the keys comparator for sorting the map
      * @param valCmp the values comparator for sorting the map
-     * @return a new builder for building a new map
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableSortedArrayMapBuilder<K,V> newBiMapComparing(Comparator<? super K> keyCmp, Comparator<? super V> valCmp) {
         ImmutableSortedArrayMapBuilder<K,V> builder = new ImmutableSortedArrayMapBuilder<>();

src/net/njcull/collections/ImmutableSortedArrayPropertyMapBuilder.java

@@ -45,7 +45,7 @@ public static <K,V> ImmutableSortedArrayPropertyMapBuilder<K,V> newMap() {
      * @param <K> the key type of the map
      * @param <V> the value type of the map
      * @param supplier the key supplier
-     * @return a new builder for building a new bimap
+     * @return a new builder for building a new map
      */
     public static <K,V> ImmutableSortedArrayPropertyMapBuilder<K,V> newMapWithKeys(Function<? super V, ? extends K> supplier) {
         ImmutableSortedArrayPropertyMapBuilder<K,V> builder = new ImmutableSortedArrayPropertyMapBuilder<>();
@@ -61,7 +61,7 @@ public static <K,V> ImmutableSortedArrayPropertyMapBuilder<K,V> newMapWithKeys(F
      * @param <V> the value type of the map
      * @param supplier the key supplier
      * @param keyCmp the key comparator
-     * @return a new builder for building a new bimap
+     * @return a new builder for building a new map
      */
     public static <K,V> ImmutableSortedArrayPropertyMapBuilder<K,V> newMapWithKeysComparing(Function<? super V, ? extends K> supplier, Comparator<? super K> keyCmp) {
         ImmutableSortedArrayPropertyMapBuilder<K,V> builder = new ImmutableSortedArrayPropertyMapBuilder<>();

src/net/njcull/collections/ImmutableUniSortedArrayMapBuilder.java

@@ -39,11 +39,11 @@ public static <K,V> ImmutableUniSortedArrayMapBuilder<K,V> newMap() {
     }
 
     /**
-     * Create a new builder instance that builds a new immutable uni-sorted bimap.
+     * Create a new builder instance that builds a new immutable uni-sorted bi-map.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
-     * @return a new builder for building a new bimap
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableUniSortedArrayMapBuilder<K,V> newBiMap() {
         ImmutableUniSortedArrayMapBuilder<K,V> builder = new ImmutableUniSortedArrayMapBuilder<>();
@@ -65,13 +65,13 @@ public static <K,V> ImmutableUniSortedArrayMapBuilder<K,V> newMapComparing(Compa
     }
 
     /**
-     * Create a new builder instance that builds a new immutable uni-sorted bimap
+     * Create a new builder instance that builds a new immutable uni-sorted bi-map
      * using the supplied comparator for sorting the keys.
      *
      * @param <K> the key type of the map
      * @param <V> the value type of the map
      * @param cmp the key comparator for sorting the map
-     * @return a new builder for building a new map
+     * @return a new builder for building a new bi-map
      */
     public static <K,V> ImmutableUniSortedArrayMapBuilder<K,V> newBiMapComparing(Comparator<? super K> cmp) {
         ImmutableUniSortedArrayMapBuilder<K,V> builder = new ImmutableUniSortedArrayMapBuilder<>();