The hash code equals the value Arrays.asList(leftValue(), rightValue()).hashCode().
Implementation of Multimap that uses an ArrayList to store the values for a given key. A HashMap associates each key with an ArrayList of values. When iterating through the collections supplied by this class, the ordering of values for a given key agrees with the order in which the values were added. This multimap allows duplicate key-value pairs. After adding a new key-value pair equal to an existing key-value pair, the ArrayListMultimap will contain entries for both the new value and the old value. Keys and values may be null. All optional multimap methods are supported, and all returned views are modifiable. The lists returned by #get, #removeAll, and #replaceValues all implement java.util.RandomAccess. This class is not threadsafe when any concurrent operations update the multimap. Concurrent read operations will work correctly. To allow concurrent update operations, wrap your multimap with a call to Multimaps#synchronizedListMultimap. See the Guava User Guide article on Multimap.
Set bGP version number spoken to the neighbor.
A builder for creating immutable multimap instances, especially public static final multimaps ("constant multimaps"). Example: static final Multimap STRING_TO_INTEGER_MULTIMAP = new ImmutableMultimap.Builder() .put("one", 1) .putAll("several", 1, 2, 3) .putAll("many", 1, 2, 3, 4, 5) .build(); Builder instances can be reused; it is safe to call #build multiple times to build multiple multimaps in series. Each multimap contains the key-value mappings in the previously created multimaps.
A Multimap<K,V> whose contents will never change, with many other important properties detailed at ImmutableCollection<E>. Warning: avoid direct usage of ImmutableMultimap<K,V> as a type (as with Multimap<K,V> itself). Prefer subtypes such as ImmutableSetMultimap<K,V> or ImmutableListMultimap<K,V>, which have well-defined #equals semantics, thus avoiding a common source of bugs and confusion. Note: every ImmutableMultimap<K,V> offers an #inverse view, so there is no need for a distinct ImmutableBiMultimap type. Key-grouped iteration. All view collections follow the same iteration order. In all current implementations, the iteration order always keeps multiple entries with the same key together. Any creation method that would customarily respect insertion order (such as <K,V>copyOf(Multimap<? extends K,? extends V> multimap)) instead preserves key-grouped order by inserting entries for an existing key immediately after the last entry having that key. See the Guava User Guide article on immutable collections.
A sorted map which forwards all its method calls to another sorted map. Subclasses should override one or more methods to modify the behavior of the backing sorted map as desired per the decorator pattern. Warning: The methods of ForwardingSortedMap forward indiscriminately to the methods of the delegate. For example, overriding #put alone will not change the behavior of #putAll, which can lead to unexpected behavior. In this case, you should override putAll as well, either providing your own implementation, or delegating to the provided standardPutAll method. default method warning: This class does not forward calls to default methods. Instead, it inherits their default implementations. When those implementations invoke methods, they invoke methods on the ForwardingSortedMap. Each of the standard methods, where appropriate, use the comparator of the map to test equality for both keys and values, unlike ForwardingMap. The standard methods and the collection views they return are not guaranteed to be thread-safe, even when all of the methods that they depend on are thread-safe.
A bimap (or "bidirectional map") is a map that preserves the uniqueness of its values as well as that of its keys. This constraint enables bimaps to support an "inverse view", which is another bimap containing the same entries as this bimap but with reversed keys and values. See the Guava User Guide article on BiMap.