org.modeshape.common.collection

## Class AbstractMultimap<K,V>

- java.lang.Object
- - org.modeshape.common.collection.AbstractMultimap<K,V>

- Type Parameters:
    `K` - the key type
    `V` - the value type
  All Implemented Interfaces:
    Multimap<K,V>
  Direct Known Subclasses:
    ArrayListMultimap, HashMultimap, LinkedHashMultimap

      public abstract class AbstractMultimap<K,V>
      extends Object
      implements Multimap<K,V>

  A `Multimap` implementation that uses an `ArrayList` to store the values associated with a key. This implementation allows duplicates.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `AbstractMultimap.EntriesCollection`
    `protected class` | `AbstractMultimap.EntryIterator`
    `protected class` | `AbstractMultimap.ValueIterator`
    `protected class` | `AbstractMultimap.ValuesCollection`
    `protected class` | `AbstractMultimap.WrappedCollection`
    `protected class` | `AbstractMultimap.WrappedKeySet`
    `protected class` | `AbstractMultimap.WrappedList`
    `protected class` | `AbstractMultimap.WrappedMap`
    `protected class` | `AbstractMultimap.WrappedSortedKeySet`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `AbstractMultimap(Map<K,Collection<V>> entries)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Map<K,Collection<V>>` | `asMap()` Return a map view that associates each key with the corresponding values in the multimap.
    `void` | `clear()` Remove all key-value pairs from this multimap.
    `boolean` | `containsEntry(Object key, Object value)` Determine whether this multimap contains the supplied key-value pair.
    `boolean` | `containsKey(K key)` Determine whether this multimap associates any values with the supplied key.
    `boolean` | `containsValue(Object value)` Determine whether this multimap associates at least one key with the supplied value.
    `protected abstract Collection<V>` | `createCollection()`
    `protected Iterator<Map.Entry<K,V>>` | `createEntryIterator()` Return an iterator over all entries in this multimap.
    `protected Collection<V>` | `createUnmodifiable(Collection<V> original)`
    `protected abstract Collection<V>` | `createUnmodifiableEmptyCollection()`
    `Collection<Map.Entry<K,V>>` | `entries()` Return a collection of all key-value pairs.
    `boolean` | `equals(Object obj)`
    `Collection<V>` | `get(K key)` Get the collection of values that are associated with the supplied key.
    `protected Collection<V>` | `getOrCreateCollection(K key)`
    `int` | `hashCode()`
    `boolean` | `isEmpty()`
    `Set<K>` | `keySet()` Return the set of keys in this multimap.
    `boolean` | `put(K key, V value)` Associate the supplied value with the given key, returning true if the size of this multimap was increased.
    `protected Map<K,Collection<V>>` | `rawData()`
    `boolean` | `remove(K key, V value)` Remove the supplied key-value pair from this multi-map.
    `Collection<V>` | `removeAll(K key)` Remove all of the key-value pairs that use the supplied key, returning the collection of values.
    `protected boolean` | `removeAllValuesForKey(Object key)`
    `int` | `size()` Return the number of key-value pairs in this multimap.
    `String` | `toString()`
    `Collection<V>` | `values()` Return a collection of all values in this multimap.
    `protected Collection<V>` | `wrapCollection(K key, Collection<V> values)`
    `protected Set<K>` | `wrapKeySet()`
    `protected List<V>` | `wrapList(K key, List<V> values)`
    `protected Map<K,Collection<V>>` | `wrapMap(Map<K,Collection<V>> map)`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### AbstractMultimap

          protected AbstractMultimap(Map<K,Collection<V>> entries)

  - ### Method Detail

    - #### rawData

          protected Map<K,Collection<V>> rawData()

    - #### createCollection

          protected abstract Collection<V> createCollection()

    - #### createUnmodifiableEmptyCollection

          protected abstract Collection<V> createUnmodifiableEmptyCollection()

    - #### createUnmodifiable

          protected Collection<V> createUnmodifiable(Collection<V> original)

    - #### size

          public int size()

      Description copied from interface: `Multimap`
      Return the number of key-value pairs in this multimap.
      Specified by:
        `size` in interface `Multimap<K,V>`
      Returns:
        the size of this multimap.

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Multimap<K,V>`

    - #### containsKey

          public boolean containsKey(K key)

      Description copied from interface: `Multimap`
      Determine whether this multimap associates any values with the supplied key.
      Specified by:
        `containsKey` in interface `Multimap<K,V>`
      Parameters:
        `key` - the key
      Returns:
        `true` if there is at least one value associated with the supplied key, or `false` otherwise

    - #### containsValue

          public boolean containsValue(Object value)

      Description copied from interface: `Multimap`
      Determine whether this multimap associates at least one key with the supplied value.
      Specified by:
        `containsValue` in interface `Multimap<K,V>`
      Parameters:
        `value` - the value
      Returns:
        `true` if there is at least one key associated with the supplied value, or `false` otherwise

    - #### containsEntry

          public boolean containsEntry(Object key,
                              Object value)

      Description copied from interface: `Multimap`
      Determine whether this multimap contains the supplied key-value pair.
      Specified by:
        `containsEntry` in interface `Multimap<K,V>`
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        `true` if this multimap contains an entry with the supplied key and value, or `false` otherwise

    - #### get

          public Collection<V> get(K key)

      Description copied from interface: `Multimap`
      Get the collection of values that are associated with the supplied key.

      Changes to the returned collection will update the values that this multimap associates with the key.

      Specified by:
        `get` in interface `Multimap<K,V>`
      Parameters:
        `key` - the key
      Returns:
        the collection of values, or an empty collection if the supplied key was not associated with any values

    - #### put

          public boolean put(K key,
                    V value)

      Description copied from interface: `Multimap`
      Associate the supplied value with the given key, returning true if the size of this multimap was increased.

      Some implementations allow duplicate key-value pairs, and in these cases this method will always increase the size of the multimap and will thus always return true. Other implementations will not allow duplicate key-value pairs, and may return false if the multimap already contains the supplied key-value pair.

      Specified by:
        `put` in interface `Multimap<K,V>`
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        `true` if the size of this multimap was increased as a result of this call, or `false` if the multimap already contained the key-value pair and doesn't allow duplicates

    - #### getOrCreateCollection

          protected Collection<V> getOrCreateCollection(K key)

    - #### remove

          public boolean remove(K key,
                       V value)

      Description copied from interface: `Multimap`
      Remove the supplied key-value pair from this multi-map.
      Specified by:
        `remove` in interface `Multimap<K,V>`
      Parameters:
        `key` - the key
        `value` - the value
      Returns:
        `true` if the size of this multimap was decreased as a result of this call, or `false` if the multimap did not contain the key-value pair

    - #### removeAll

          public Collection<V> removeAll(K key)

      Description copied from interface: `Multimap`
      Remove all of the key-value pairs that use the supplied key, returning the collection of values. The resulting collection may be modifiable, but changing it will have no effect on this multimap.
      Specified by:
        `removeAll` in interface `Multimap<K,V>`
      Parameters:
        `key` - the key
      Returns:
        the collection of values that were removed, or an empty collection if there were none; never null

    - #### removeAllValuesForKey

          protected boolean removeAllValuesForKey(Object key)

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object obj)

      Overrides:
        `equals` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### keySet

          public Set<K> keySet()

      Description copied from interface: `Multimap`
      Return the set of keys in this multimap.
      Specified by:
        `keySet` in interface `Multimap<K,V>`
      Returns:
        the set of keys; never null but possible empty

    - #### clear

          public void clear()

      Description copied from interface: `Multimap`
      Remove all key-value pairs from this multimap.
      Specified by:
        `clear` in interface `Multimap<K,V>`

    - #### asMap

          public Map<K,Collection<V>> asMap()

      Description copied from interface: `Multimap`
      Return a map view that associates each key with the corresponding values in the multimap. Changes to the returned map, such as element removal, will update the underlying multimap. The map does not support `setValue()` on its entries, `put`, or `putAll`.

      The collections returned by `asMap().get(Object)` have the same behavior as those returned by `Multimap.get(K)`.

      Specified by:
        `asMap` in interface `Multimap<K,V>`
      Returns:
        a map view from a key to its collection of values

    - #### createEntryIterator

          protected Iterator<Map.Entry<K,V>> createEntryIterator()

      Return an iterator over all entries in this multimap.
      Returns:
        the entry iterator; never null

    - #### wrapCollection

          protected Collection<V> wrapCollection(K key,
                                     Collection<V> values)

    - #### wrapList

          protected List<V> wrapList(K key,
                         List<V> values)

    - #### wrapMap

          protected Map<K,Collection<V>> wrapMap(Map<K,Collection<V>> map)

    - #### wrapKeySet

          protected Set<K> wrapKeySet()

    - #### values

          public Collection<V> values()

      Description copied from interface: `Multimap`
      Return a collection of all values in this multimap. Changes to the returned collection will update the underlying multimap, and vice versa.
      Specified by:
        `values` in interface `Multimap<K,V>`
      Returns:
        the collection of values, which may include the same value multiple times if it occurs in multiple mappings; never null but possibly empty

    - #### entries

          public Collection<Map.Entry<K,V>> entries()

      Description copied from interface: `Multimap`
      Return a collection of all key-value pairs. Changes to the returned collection will update the underlying multimap, and vice versa. The entries collection does not support the `add` or `addAll` operations.
      Specified by:
        `entries` in interface `Multimap<K,V>`
      Returns:
        the collection of map entries consisting of key-value pairs; never null but possibly empty

Copyright © 2008-2014 JBoss, a division of Red Hat. All Rights Reserved.