Maps

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(key: K): IO[Level0Meter]

Removes all key-values from the target Map.

def clone(): AnyRef

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

val count: Option[Int]

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

final def eq(arg0: AnyRef): Boolean

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[Map[K, V]]]

final def getClass(): Class[_]

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

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

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

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

final def isInstanceOf[T0]: Boolean

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 map[B](f: ((K, V)) ⇒ B): IO[Stream[B, IO]]

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

val mapKey: Seq[K]

val mapsOnly: 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 put(key: K, value: V): IO[Map[K, V]]

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]

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 toSeq: IO[Seq[(K, V)]]

def toString(): String

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

val userDefinedFrom: Boolean

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit