Class SetMap<K,V>

java.lang.Object
com.pnfsoftware.jeb.util.collect.SetMap<K,V>
Type Parameters:
K - key type
V - type of value to be stored

@Ser public class SetMap<K,V> extends Object
A map of keys to sets. Keys may be ordered (none, natural, by insertion); the ordering for the value sets may be specified as well. This class is serialializable. Null key is allowed; null values are allowed.

Thread-safety: none.

Note: this class does not implement the Map interface, but attempts to follow its guidelines and contracts the best it can. One notable exception is that this class does not override hashCode/equals.

  • Constructor Details

    • SetMap

      public SetMap()
      Create a new set-map without any particular ordering.
    • SetMap

      public SetMap(CollectionOrder keyOrder, CollectionOrder setOrder)
      Create a new set-map.
      Parameters:
      keyOrder - key ordering
      setOrder - value-set ordering
  • Method Details

    • clear

      public void clear()
    • keySize

      public int keySize()
    • isEmpty

      public boolean isEmpty()
    • size

      public int size()
      Get the number of key-value mappings (per Map interface). That is, the number of values.
      Returns:
    • put

      public int put(K key, V value)
      Add a key-value mapping.
      Parameters:
      key -
      value -
      Returns:
      the updated count of values associated with the key
    • putMulti

      public void putMulti(K key, Collection<? extends V> values)
      Add multiple elements mapped by the same key. Note that if an empty collection is provided, the entry for the provided key will not be be explicitly created.
      Parameters:
      key -
      values -
    • putAll

      public void putAll(Map<? extends K,List<? extends V>> m)
    • createKey

      public boolean createKey(K key)
      Create an explicit entry for a given key. If no values mapped by the given key previously existed, the associated value will be an empty collection.
      Parameters:
      key -
      Returns:
      true if the map did not already contain the key; false otherwise (the key entry existed before)
    • containsKey

      public boolean containsKey(K key)
    • containsValue

      public boolean containsValue(V value)
    • get

      public Set<V> get(K key)
    • get

      public Set<V> get(K key, boolean safe)
      Parameters:
      safe - if true, an empty collection of values is returned if the key does not exist
      Returns:
    • getSafe

      public Set<V> getSafe(K key)
    • remove

      public Set<V> remove(K key)
    • removeValue

      public V removeValue(K key, V value)
    • removeMulti

      public int removeMulti(K key, Collection<? extends V> values)
    • values

      public Set<V> values()
    • keySet

      public Set<K> keySet()
      Retrieve a read-only view of the keys.

      WARNING: This method does not respect the Map.keySet() contract: the set returned is read-only.

      Returns:
      read-only view of the key set
    • removeAll

      public boolean removeAll(Collection<K> keys)
      Remove all entries mapping to the collection of keys.

      Similar semantics as Set.removeAll(Collection).

      Parameters:
      keys -
      Returns:
      true if the multi-map was modified
    • toString

      public String toString()
      Overrides:
      toString in class Object