Map

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def after(key: K): MapStream[K, V]

final def asInstanceOf[T0]: T0

def before(key: K): MapStream[K, V]

def clear(): IO[Level0Meter]

Removes all key-values from the current Map.

def clone(): AnyRef

def closeDatabase(): IO[Unit]

def commit(prepare: Iterable[Prepare[K, V]]): IO[Level0Meter]

def commit(entries: Prepare[MapEntry[K], Option[V]]*): IO[Level0Meter]

def commitPrepared(prepare: Prepare[K, V]*): IO[Level0Meter]

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

val count: Option[Int]

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

final def eq(arg0: AnyRef): Boolean

def exists(): IO[Boolean]

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

def expire(keys: Iterable[(K, Deadline)]): IO[Level0Meter]

def expire(keys: (K, Deadline)*): IO[Level0Meter]

def expire(from: K, to: K, at: Deadline): IO[Level0Meter]

def expire(from: K, to: K, after: FiniteDuration): IO[Level0Meter]

def expire(key: K, at: Deadline): IO[Level0Meter]

def expire(key: K, after: FiniteDuration): IO[Level0Meter]

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

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

def from(key: K): MapStream[K, V]

def fromOrAfter(key: K): MapStream[K, V]

def fromOrBefore(key: K): MapStream[K, V]

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

Returns target value for the input key.

final def getClass(): Class[_]

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

Returns target full key for the input partial key.

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

def getValue(): IO[Option[V]]

Returns None if the map does not exist or returns the value.

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

final def isInstanceOf[T0]: Boolean

def keySize(key: K): Int

def keys: MapKeysStream[K]

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

lastOption should always force formKey to be the endSubMapsKey because from is always set in swaydb.extensions.Maps and regardless from where the iteration starts the most efficient way to fetch the last is from the key endSubMapsKey.

def lastOptionStream: IO[Option[(K, V)]]

def level0Meter: Level0Meter

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

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

val map: swaydb.Map[Key[K], Option[V], IO]

val mapKey: Seq[K]

def maps: Maps[K, V]

val mapsOnly: Boolean

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

final def ne(arg0: AnyRef): Boolean

def next(previous: (K, V)): IO[Option[(K, V)]]

final def notify(): Unit

final def notifyAll(): Unit

def preparePut(key: K, value: V, deadline: Deadline): Prepare[MapEntry[K], Option[V]]

def preparePut(key: K, value: V, expireAfter: FiniteDuration): Prepare[MapEntry[K], Option[V]]

def preparePut(key: K, value: V): Prepare[MapEntry[K], Option[V]]

def prepareRemove(from: K, to: K): Prepare[MapEntry[K], Option[V]]

def prepareRemove(key: K): Prepare[MapEntry[K], Option[V]]

def put(keyValues: Iterable[(K, V)]): IO[Level0Meter]

def put(keyValues: (K, V)*): IO[Level0Meter]

def put(key: K, value: V, expireAt: Deadline): IO[Level0Meter]

def put(key: K, value: V, expireAfter: FiniteDuration): IO[Level0Meter]

def put(key: K, value: V): IO[Level0Meter]

def remove(keys: Iterable[K]): IO[Level0Meter]

def remove(keys: K*): IO[Level0Meter]

def remove(from: K, to: K): IO[Level0Meter]

def remove(key: K): IO[Level0Meter]

def restart: Stream[(K, V), IO]

def reverse: MapStream[K, V]

Returns the start key when doing reverse iteration.

def size: IO[Int]

def sizeOfSegments: Long

val skip: Int

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

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

def takeWhile(condition: (K, V) ⇒ Boolean): MapStream[K, V]

def takeWhileKey(condition: (K) ⇒ Boolean): MapStream[K, V]

def takeWhileValue(condition: (V) ⇒ Boolean): MapStream[K, V]

val till: (K, V) ⇒ Boolean

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

def toSeq: IO[Seq[(K, V)]]

def toString(): String

def update(keyValues: Iterable[(K, V)]): IO[Level0Meter]

def update(keyValues: (K, V)*): IO[Level0Meter]

def update(from: K, to: K, value: V): IO[Level0Meter]

def update(key: K, value: V): IO[Level0Meter]

def updateValue(value: V): IO[Map[K, V]]

val userDefinedFrom: Boolean

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