Map

Instance Constructors

new Map(core: Core[W], count: Option[Int] = None, skip: Int = 0, from: Option[From[K]] = None, reverseIteration: Boolean = false, till: Option[(K, V) ⇒ Boolean] = None)(implicit keySerializer: Serializer[K], valueSerializer: Serializer[V], wrap: Wrap[W])

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): Map[K, V, W]
def applyFunction(from: K, to: K, functionID: K): W[Level0Meter]
def applyFunction(key: K, functionID: K): W[Level0Meter]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def async(implicit futureWrap: Wrap[Future], ec: ExecutionContext): Map[K, V, Future]
def before(key: K): Map[K, V, W]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def closeDatabase(): W[Unit]
def commit(prepare: Iterable[Prepare[K, V]]): W[Level0Meter]
def commit(prepare: Prepare[K, V]*): W[Level0Meter]
def contains(key: K): W[Boolean]
def drop(count: Int): Map[K, V, W]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def expiration(key: K): W[Option[Deadline]]
def expire(keys: Iterable[(K, Deadline)]): W[Level0Meter]
def expire(keys: (K, Deadline)*): W[Level0Meter]
def expire(from: K, to: K, at: Deadline): W[Level0Meter]
def expire(from: K, to: K, after: FiniteDuration): W[Level0Meter]
def expire(key: K, at: Deadline): W[Level0Meter]
def expire(key: K, after: FiniteDuration): W[Level0Meter]
def foldLeft[B](initial: B)(f: (B, (K, V)) ⇒ B): W[B]

Definition Classes
Stream
def foreach[U](f: ((K, V)) ⇒ U): W[Unit]

Definition Classes
Stream
def from(key: K): Map[K, V, W]
def fromOrAfter(key: K): Map[K, V, W]
def fromOrBefore(key: K): Map[K, V, W]
def get(key: K): W[Option[V]]

Returns target value for the input key.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def getKey(key: K): W[Option[K]]

Returns target full key for the input partial key.
Returns target full key for the input partial key.
This function is mostly used for Set databases where partial ordering on the Key is provided.
def getKeyValue(key: K): W[Option[(K, V)]]
def headOption: W[Option[(K, V)]]

Definition Classes
Map → Stream
def isEmpty: W[Boolean]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def keySize(key: K): Int
def keys: Set[K, W]
def lastOption: W[Option[(K, V)]]
def lastOptionStream: W[Option[(K, V)]]

Definition Classes
Stream
def level0Meter: Level0Meter
def levelMeter(levelNumber: Int): Option[LevelMeter]
def map[B](f: ((K, V)) ⇒ B): W[Stream[B, W]]

Definition Classes
Stream
def mightContain(key: K): W[Boolean]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(previous: (K, V)): W[Option[(K, V)]]

Definition Classes
Map → Stream
def nonEmpty: W[Boolean]
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def put(keyValues: Iterable[(K, V)]): W[Level0Meter]
def put(keyValues: (K, V)*): W[Level0Meter]
def put(key: K, value: V, expireAt: Deadline): W[Level0Meter]
def put(key: K, value: V, expireAfter: FiniteDuration): W[Level0Meter]
def put(key: K, value: V): W[Level0Meter]
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]): W[Level0Meter]
def remove(keys: K*): W[Level0Meter]
def remove(from: K, to: K): W[Level0Meter]
def remove(key: K): W[Level0Meter]
def restart: Map[K, V, W]

Definition Classes
Map → Stream
def reverse: Map[K, V, W]
def size: W[Int]
def sizeOfSegments: Long
def syncIO(implicit ioWrap: Wrap[IO], ec: ExecutionContext): Map[K, V, IO]
def syncTry(implicit tryWrap: Wrap[Try], ec: ExecutionContext): Map[K, V, Try]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(count: Int): Map[K, V, W]
def takeWhile(condition: (K, V) ⇒ Boolean): Map[K, V, W]
def takeWhileKey(condition: (K) ⇒ Boolean): Map[K, V, W]
def takeWhileValue(condition: (V) ⇒ Boolean): Map[K, V, W]
def timeLeft(key: K): W[Option[FiniteDuration]]
def toSeq: W[Seq[(K, V)]]

Definition Classes
Stream
def toString(): String

Definition Classes
Map → AnyRef → Any
def update(keyValues: Iterable[(K, V)]): W[Level0Meter]
def update(keyValues: (K, V)*): W[Level0Meter]
def update(from: K, to: K, value: V): W[Level0Meter]
def update(key: K, value: V): W[Level0Meter]
def valueSize(value: V): Int
final def wait(arg0: Long, arg1: Int): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def wrapCall[C](f: ⇒ W[C]): W[C]

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Doc: package swaydb

Instance Constructors

new Map(core: Core[W], count: Option[Int] = None, skip: Int = 0, from: Option[From[K]] = None, reverseIteration: Boolean = false, till: Option[(K, V) ⇒ Boolean] = None)(implicit keySerializer: Serializer[K], valueSerializer: Serializer[V], wrap: Wrap[W])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

def applyFunction(from: K, to: K, functionID: K): W[Level0Meter]

def applyFunction(key: K, functionID: K): W[Level0Meter]

final def asInstanceOf[T0]: T0

def async(implicit futureWrap: Wrap[Future], ec: ExecutionContext): Map[K, V, Future]

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

def clone(): AnyRef

def closeDatabase(): W[Unit]

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

def commit(prepare: Prepare[K, V]*): W[Level0Meter]

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

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

final def eq(arg0: AnyRef): Boolean

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

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

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

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

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

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

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

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

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

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

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

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

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

final def getClass(): Class[_]

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

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

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

def isEmpty: W[Boolean]

final def isInstanceOf[T0]: Boolean

def keySize(key: K): Int

def keys: Set[K, W]

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

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

def level0Meter: Level0Meter

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

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

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

final def ne(arg0: AnyRef): Boolean

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

def nonEmpty: W[Boolean]

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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]): W[Level0Meter]

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

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

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

def restart: Map[K, V, W]

def reverse: Map[K, V, W]

def size: W[Int]

def sizeOfSegments: Long

def syncIO(implicit ioWrap: Wrap[IO], ec: ExecutionContext): Map[K, V, IO]

def syncTry(implicit tryWrap: Wrap[Try], ec: ExecutionContext): Map[K, V, Try]

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

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

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

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

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

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

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

def toString(): String

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