Packages

final class TMap[K, V] extends AnyRef

Transactional map implemented on top of TRef and TArray. Resolves conflicts via chaining.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TMap
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  6. def contains(k: K): USTM[Boolean]

    Tests whether or not map contains a key.

  7. def delete(k: K): USTM[Unit]

    Removes binding for given key.

  8. def deleteAll(ks: Iterable[K]): USTM[Unit]

    Deletes all entries associated with the specified keys.

  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  12. def find[A](pf: PartialFunction[(K, V), A]): USTM[Option[A]]

    Finds the key/value pair matching the specified predicate, and uses the provided function to extract a value out of it.

  13. def findAll[A](pf: PartialFunction[(K, V), A]): USTM[Chunk[A]]

    Finds all the key/value pairs matching the specified predicate, and uses the provided function to extract values out them.

  14. def findAllSTM[R, E, A](pf: (K, V) ⇒ ZSTM[R, Option[E], A]): ZSTM[R, E, Chunk[A]]

    Finds all the key/value pairs matching the specified predicate, and uses the provided effectful function to extract values out of them..

  15. def findSTM[R, E, A](f: (K, V) ⇒ ZSTM[R, Option[E], A]): ZSTM[R, E, Option[A]]

    Finds the key/value pair matching the specified predicate, and uses the provided effectful function to extract a value out of it.

  16. def fold[A](zero: A)(op: (A, (K, V)) ⇒ A): USTM[A]

    Atomically folds using a pure function.

  17. def foldSTM[R, E, A](zero: A)(op: (A, (K, V)) ⇒ ZSTM[R, E, A]): ZSTM[R, E, A]

    Atomically folds using a transactional function.

  18. def foreach[R, E](f: (K, V) ⇒ ZSTM[R, E, Unit]): ZSTM[R, E, Unit]

    Atomically performs transactional-effect for each binding present in map.

  19. def get(k: K): USTM[Option[V]]

    Retrieves value associated with given key.

  20. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  21. def getOrElse(k: K, default: ⇒ V): USTM[V]

    Retrieves value associated with given key or default value, in case the key isn't present.

  22. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  23. def isEmpty: USTM[Boolean]

    Tests if the map is empty or not

  24. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  25. def keys: USTM[List[K]]

    Collects all keys stored in map.

  26. def merge(k: K, v: V)(f: (V, V) ⇒ V): USTM[V]

    If the key k is not already associated with a value, stores the provided value, otherwise merge the existing value with the new one using function f and store the result

  27. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  28. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  29. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  30. def put(k: K, v: V): USTM[Unit]

    Stores new binding into the map.

  31. def putIfAbsent(k: K, v: V): USTM[Unit]

    Stores new binding in the map if it does not already exist.

  32. def removeIf(p: (K, V) ⇒ Boolean): USTM[Unit]

    Removes bindings matching predicate.

  33. def retainIf(p: (K, V) ⇒ Boolean): USTM[Unit]

    Retains bindings matching predicate.

  34. val size: USTM[Int]

    Returns the number of bindings.

  35. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  36. def takeFirst[A](pf: PartialFunction[(K, V), A]): USTM[A]

    Takes the first matching value, or retries until there is one.

  37. def takeFirstSTM[R, E, A](pf: (K, V) ⇒ ZSTM[R, Option[E], A]): ZSTM[R, E, A]
  38. def takeSome[A](pf: PartialFunction[(K, V), A]): USTM[NonEmptyChunk[A]]

    Takes all matching values, or retries until there is at least one.

  39. def takeSomeSTM[R, E, A](pf: (K, V) ⇒ ZSTM[R, Option[E], A]): ZSTM[R, E, NonEmptyChunk[A]]

    Takes all matching values, or retries until there is at least one.

  40. def toChunk: USTM[Chunk[(K, V)]]

    Collects all bindings into a chunk.

  41. def toList: USTM[List[(K, V)]]

    Collects all bindings into a list.

  42. def toMap: USTM[Map[K, V]]

    Collects all bindings into a map.

  43. def toString(): String
    Definition Classes
    AnyRef → Any
  44. def transform(f: (K, V) ⇒ (K, V)): USTM[Unit]

    Atomically updates all bindings using a pure function.

  45. def transformSTM[R, E](f: (K, V) ⇒ ZSTM[R, E, (K, V)]): ZSTM[R, E, Unit]

    Atomically updates all bindings using a transactional function.

  46. def transformValues(f: (V) ⇒ V): USTM[Unit]

    Atomically updates all values using a pure function.

  47. def transformValuesSTM[R, E](f: (V) ⇒ ZSTM[R, E, V]): ZSTM[R, E, Unit]

    Atomically updates all values using a transactional function.

  48. def values: USTM[List[V]]

    Collects all values stored in map.

  49. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  50. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  51. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Deprecated Value Members

  1. def foldM[R, E, A](zero: A)(op: (A, (K, V)) ⇒ ZSTM[R, E, A]): ZSTM[R, E, A]

    Atomically folds using a transactional function.

    Atomically folds using a transactional function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use foldSTM

  2. def transformM[E](f: (K, V) ⇒ STM[E, (K, V)]): STM[E, Unit]

    Atomically updates all bindings using a transactional function.

    Atomically updates all bindings using a transactional function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use transformSTM

  3. def transformValuesM[E](f: (V) ⇒ STM[E, V]): STM[E, Unit]

    Atomically updates all values using a transactional function.

    Atomically updates all values using a transactional function.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use transformValuesSTM

Inherited from AnyRef

Inherited from Any

Ungrouped