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): ApiIO[Done]

Removes all key-values from the target Map.

def clone(): AnyRef

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

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

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

final def eq(arg0: AnyRef): Boolean

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

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

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

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

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

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): ApiIO[Option[Map[K, V]]]

final def getClass(): Class[_]

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

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

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

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

final def isInstanceOf[T0]: Boolean

def isReverse: Boolean

def keys: MapKeysStream[K]

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

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

val mapKey: Seq[K]

val mapsOnly: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def put(key: K, value: V): ApiIO[Map[K, V]]

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

def reverse: MapStream[K, V]

Returns the start key when doing reverse iteration.

def size: ApiIO[Int]

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

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

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

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

def toString(): String

def updateValue(key: K, value: V): ApiIO[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