Map

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def after(key: K): Map[K, V, T]

def applyFunction(from: K, to: K, functionID: K): T[Done]

def applyFunction(key: K, functionID: K): T[Done]

final def asInstanceOf[T0]: T0

def asScala: scala.collection.mutable.Map[K, V]

def before(key: K): Map[K, V, T]

def clear(): T[Done]

def clone(): AnyRef

def close(): T[Unit]

def commit(prepare: Iterable[Prepare[K, V]]): T[Done]

def commit(prepare: Stream[Prepare[K, V], T]): T[Done]

def commit(prepare: Prepare[K, V]*): T[Done]

def contains(key: K): T[Boolean]

def delete(): T[Unit]

def drop(count: Int): Stream[(K, V), T]

def dropWhile(f: ((K, V)) ⇒ Boolean): Stream[(K, V), T]

final def eq(arg0: AnyRef): Boolean

def expiration(key: K): T[Option[Deadline]]

def expire(keys: Iterable[(K, Deadline)]): T[Done]

def expire(keys: Stream[(K, Deadline), T]): T[Done]

def expire(keys: (K, Deadline)*): T[Done]

def expire(from: K, to: K, at: Deadline): T[Done]

def expire(from: K, to: K, after: FiniteDuration): T[Done]

def expire(key: K, at: Deadline): T[Done]

def expire(key: K, after: FiniteDuration): T[Done]

def filter(f: ((K, V)) ⇒ Boolean): Stream[(K, V), T]

def filterNot(f: ((K, V)) ⇒ Boolean): Stream[(K, V), T]

def flatMap[B](f: ((K, V)) ⇒ Stream[B, T]): Stream[B, T]

def foldLeft[B](initial: B)(f: (B, (K, V)) ⇒ B): T[B]

def foreach[U](f: ((K, V)) ⇒ U): Stream[Unit, T]

def from(key: K): Map[K, V, T]

def fromOrAfter(key: K): Map[K, V, T]

def fromOrBefore(key: K): Map[K, V, T]

def get(key: K): T[Option[V]]

Returns target value for the input key.

final def getClass(): Class[_]

def getKey(key: K): T[Option[K]]

Returns target full key for the input partial key.

def getKeyValue(key: K): T[Option[(K, V)]]

def headOption: T[Option[(K, V)]]

def isEmpty: T[Boolean]

final def isInstanceOf[T0]: Boolean

def keySize(key: K): Int

def keys: Set[K, T]

def lastOption: T[Option[(K, V)]]

def level0Meter: LevelZeroMeter

def levelMeter(levelNumber: Int): Option[LevelMeter]

def map[B](f: ((K, V)) ⇒ B): Stream[B, T]

def mightContain(key: K): T[Boolean]

def mightContainFunction(functionId: K): T[Boolean]

final def ne(arg0: AnyRef): Boolean

def nonEmpty: T[Boolean]

final def notify(): Unit

final def notifyAll(): Unit

def put(keyValues: Iterable[(K, V)]): T[Done]

def put(keyValues: Stream[(K, V), T]): T[Done]

def put(keyValues: (K, V)*): T[Done]

def put(key: K, value: V, expireAt: Deadline): T[Done]

def put(key: K, value: V, expireAfter: FiniteDuration): T[Done]

def put(key: K, value: V): T[Done]

def registerFunction(functionID: K, function: (K, V, Option[Deadline]) ⇒ Apply.Map[V]): K

def registerFunction(functionID: K, function: (K, Option[Deadline]) ⇒ Apply.Map[V]): K

def registerFunction(functionID: K, function: (V) ⇒ Apply.Map[V]): K

def remove(keys: Iterable[K]): T[Done]

def remove(keys: Stream[K, T]): T[Done]

def remove(keys: K*): T[Done]

def remove(from: K, to: K): T[Done]

def remove(key: K): T[Done]

def reverse: Map[K, V, T]

def size: T[Int]

def sizeOfBloomFilterEntries: T[Int]

def sizeOfSegments: Long

def stream: Stream[(K, V), T]

final def synchronized[T0](arg0: ⇒ T0): T0

def take(count: Int): Stream[(K, V), T]

def takeWhile(f: ((K, V)) ⇒ Boolean): Stream[(K, V), T]

def timeLeft(key: K): T[Option[FiniteDuration]]

def toString(): String

def toTag[X[_]](implicit tag: Tag[X]): Map[K, V, X]

Returns an Async API of type O where the Tag is known.

def update(keyValues: Iterable[(K, V)]): T[Done]

def update(keyValues: Stream[(K, V), T]): T[Done]

def update(keyValues: (K, V)*): T[Done]

def update(from: K, to: K, value: V): T[Done]

def update(key: K, value: V): T[Done]

def valueSize(value: V): Int

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit