Package org.apache.pekko.util

Class TypedMultiMap<T,K>

java.lang.Object
org.apache.pekko.util.TypedMultiMap<T,K>
public class TypedMultiMap<T,K> extends Object
An immutable multi-map that expresses the value type as a type function of the key type. Create it with a type constructor that expresses the relationship: 


 trait Key { type Type = T }
 case class MyValue[T](...)

 // type function from Key to MyValue
 type KV[K <: Key] = MyValue[K#Type]

 val map = TypedMultiMap.empty[Key, KV]

 // a plain Int => String map would use this function:
 type plain[K <: Int] = String

 // a map T => T would use this function:
 type identity[T <: AnyRef] = T

Caveat: using keys which take type parameters does not work due to conflicts with the existential interpretation of Key[_]. A workaround is to define a key type like above and provide a subtype that provides its type parameter as type member Type.

  • Constructor Details

    • TypedMultiMap

      public TypedMultiMap()

  • Method Details

    • empty

      public static <T, K> TypedMultiMap<T,K> empty()
      Obtain the empty map for the given key type and key–value type function.

    • keySet

      public scala.collection.immutable.Set<T> keySet()
      Return the set of keys which are mapped to non-empty value sets.

    • inserted

      public TypedMultiMap<T,K> inserted(T key, K value)
      Return a map that has the given value added to the mappings for the given key.

    • get

      public scala.collection.immutable.Set<K> get(T key)
      Obtain all mappings for the given key.

    • valueRemoved

      public TypedMultiMap<T,K> valueRemoved(Object value)
      Return a map that has the given value removed from all keys.

    • keyRemoved

      public TypedMultiMap<T,K> keyRemoved(T key)
      Return a map that has all mappings for the given key removed.

    • removed

      public TypedMultiMap<T,K> removed(T key, K value)
      Return a map that has the given mapping from the given key removed.

    • setAll

      public TypedMultiMap<T,K> setAll(T key, scala.collection.immutable.Set<K> values)

    • $plus$plus

      public TypedMultiMap<T,K> $plus$plus(TypedMultiMap<T,K> other)
      Add all entries from the other map, overwriting existing entries.

      FIXME: should it merge, instead?

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object other)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object