Maps

Instance Constructors

new Maps(map: swaydb.Map[Key[K], Option[V], Nothing, ApiIO], mapKey: Seq[K])(implicit keySerializer: Serializer[K], mapKeySerializer: Serializer[Key[K]], keyOrder: KeyOrder[Slice[Byte]], valueSerializerOption: Serializer[Option[V]], valueSerializer: Serializer[V])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def after(key: K): MapStream[K, V]

Definition Classes
MapStream
final def asInstanceOf[T0]: T0

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

Definition Classes
MapStream
def clear(key: K): ApiIO[Done]

Removes all key-values from the target Map.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contains(key: K): ApiIO[Boolean]
def drop(count: Int): Stream[(K, V), ApiIO]

Definition Classes
MapStream → Streamable
def dropWhile(f: ((K, V)) ⇒ Boolean): Stream[(K, V), ApiIO]

Definition Classes
MapStream → Streamable
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
MapStream → Streamable
def filterNot(f: ((K, V)) ⇒ Boolean): Stream[(K, V), ApiIO]

Definition Classes
MapStream → Streamable
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[B](f: ((K, V)) ⇒ Stream[B, ApiIO]): Stream[B, ApiIO]

Definition Classes
MapStream → Streamable
def foldLeft[B](initial: B)(f: (B, (K, V)) ⇒ B): ApiIO[B]

Definition Classes
MapStream → Streamable
def foreach[U](f: ((K, V)) ⇒ U): Stream[Unit, ApiIO]

Definition Classes
MapStream → Streamable
def from(key: K): MapStream[K, V]

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

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

Definition Classes
MapStream
def get(key: K): ApiIO[Option[Map[K, V]]]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
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)]]

Definition Classes
MapStream → Streamable
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isReverse: Boolean

Definition Classes
MapStream
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.
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.

Definition Classes
MapStream → Streamable
def map[B](f: ((K, V)) ⇒ B): Stream[B, ApiIO]

Definition Classes
MapStream → Streamable
val map: swaydb.Map[Key[K], Option[V], Nothing, ApiIO]

Definition Classes
MapStream
val mapKey: Seq[K]

Definition Classes
MapStream
val mapsOnly: Boolean

Definition Classes
MapStream
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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.
Returns the start key when doing reverse iteration.
If subMaps are included then it will return the starting point to be Key.SubMapsEnd which will iterate backward until Key.MapEntriesStart else returns the starting point to be Key.MapEntriesEnd to fetch entries only.

Definition Classes
MapStream
def size: ApiIO[Int]

Definition Classes
Maps → MapStream → Streamable
def stream: Stream[(K, V), ApiIO]

Definition Classes
MapStream
final def synchronized[T0](arg0: ⇒ T0): T0

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

Definition Classes
MapStream → Streamable
def takeWhile(f: ((K, V)) ⇒ Boolean): Stream[(K, V), ApiIO]

Definition Classes
MapStream → Streamable
def toString(): String

Definition Classes
MapStream → AnyRef → Any
def updateValue(key: K, value: V): ApiIO[Map[K, V]]
val userDefinedFrom: Boolean

Definition Classes
MapStream
final def wait(): Unit

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

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package extensions

class Maps[K, V] extends MapStream[K, V]

Instance Constructors

new Maps(map: swaydb.Map[Key[K], Option[V], Nothing, ApiIO], mapKey: Seq[K])(implicit keySerializer: Serializer[K], mapKeySerializer: Serializer[Key[K]], keyOrder: KeyOrder[Slice[Byte]], valueSerializerOption: Serializer[Option[V]], valueSerializer: Serializer[V])

Value Members

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]

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 finalize(): Unit

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]]

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

final def isInstanceOf[T0]: Boolean

def isReverse: Boolean

def keys: MapKeysStream[K]

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

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]

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(): Unit

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

final def wait(arg0: Long): Unit

Inherited from MapStream[K, V]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Streamable[(K, V), ApiIO]

Inherited from AnyRef

Inherited from Any

Ungrouped