Map

Instance Constructors

new Map(core: Core[W], from: Option[From[K]] = None, reverseIteration: Boolean = false)(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 asScala: scala.collection.mutable.Map[K, V]
def asyncAPI[O[_]](implicit ec: ExecutionContext, transform: FutureTransformer[O], wrap: Wrap[O]): Map[K, V, O]

Returns an Async API of type O where the Wrap is known.
Returns an Async API of type O where the Wrap is known.
Wrapper will be built from FutureTransformer.
def asyncAPI[O[_]](timeout: FiniteDuration)(implicit ec: ExecutionContext, transform: FutureTransformer[O]): Map[K, V, O]

Returns an Async API of type O where the Wrap is not known.
Returns an Async API of type O where the Wrap is not known.
Wrapper will be built from FutureTransformer.
timeout
is used only when a async API gets converted into a blocking API otherwise it's always non-blocking.
def before(key: K): Map[K, V, W]
def blockingAPI[O[_]](implicit transform: IOTransformer[O], wrap: Wrap[O]): Map[K, V, O]

Returns an blocking API of type O where the Wrap is known.
def blockingAPI[O[_]](implicit transform: IOTransformer[O]): Map[K, V, O]

Returns an blocking API of type O where the Wrap is not known.
Returns an blocking API of type O where the Wrap is not known.
Wrapper will be built from IOTransformer.
def clear(): W[Level0Meter]
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: Stream[Prepare[K, V], W]): W[Level0Meter]
def commit(prepare: Prepare[K, V]*): W[Level0Meter]
def contains(key: K): W[Boolean]
def drop(count: Int): Stream[(K, V), W]

Definition Classes
Map → Streamer
def dropWhile(f: ((K, V)) ⇒ Boolean): Stream[(K, V), W]

Definition Classes
Map → Streamer
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: Stream[(K, Deadline), W]): 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 filter(f: ((K, V)) ⇒ Boolean): Stream[(K, V), W]

Definition Classes
Map → Streamer
def filterNot(f: ((K, V)) ⇒ Boolean): Stream[(K, V), W]

Definition Classes
Map → Streamer
def foldLeft[B](initial: B)(f: (B, (K, V)) ⇒ B): W[B]

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

Definition Classes
Map → Streamer
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 → Streamer
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)]]

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

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

Definition Classes
AnyRef
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: Stream[(K, V), W]): 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: Stream[K, W]): W[Level0Meter]
def remove(keys: K*): W[Level0Meter]
def remove(from: K, to: K): W[Level0Meter]
def remove(key: K): W[Level0Meter]
def reverse: Map[K, V, W]
def size: W[Int]

Definition Classes
Map → Streamer
def sizeOfBloomFilterEntries: W[Int]
def sizeOfSegments: Long
def stream: Stream[(K, V), W]
final def synchronized[T0](arg0: ⇒ T0): T0

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

Definition Classes
Map → Streamer
def takeWhile(f: ((K, V)) ⇒ Boolean): Stream[(K, V), W]

Definition Classes
Map → Streamer
def timeLeft(key: K): W[Option[FiniteDuration]]
def toString(): String

Definition Classes
Map → AnyRef → Any
def update(keyValues: Iterable[(K, V)]): W[Level0Meter]
def update(keyValues: Stream[(K, V), W]): 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

case class Map[K, V, W[_]](core: Core[W], from: Option[From[K]] = None, reverseIteration: Boolean = false)(implicit keySerializer: Serializer[K], valueSerializer: Serializer[V], wrap: Wrap[W]) extends Streamer[(K, V), W] with Product with Serializable

Instance Constructors

new Map(core: Core[W], from: Option[From[K]] = None, reverseIteration: Boolean = false)(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 asScala: scala.collection.mutable.Map[K, V]

def asyncAPI[O[_]](implicit ec: ExecutionContext, transform: FutureTransformer[O], wrap: Wrap[O]): Map[K, V, O]

def asyncAPI[O[_]](timeout: FiniteDuration)(implicit ec: ExecutionContext, transform: FutureTransformer[O]): Map[K, V, O]

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

def blockingAPI[O[_]](implicit transform: IOTransformer[O], wrap: Wrap[O]): Map[K, V, O]

def blockingAPI[O[_]](implicit transform: IOTransformer[O]): Map[K, V, O]

def clear(): W[Level0Meter]

def clone(): AnyRef

def closeDatabase(): W[Unit]

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

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

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

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

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

def dropWhile(f: ((K, V)) ⇒ Boolean): Stream[(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: Stream[(K, Deadline), W]): 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 filter(f: ((K, V)) ⇒ Boolean): Stream[(K, V), W]

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

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

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

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 level0Meter: Level0Meter

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

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

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

final def ne(arg0: AnyRef): Boolean

def nonEmpty: W[Boolean]

final def notify(): Unit

final def notifyAll(): Unit

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

def put(keyValues: Stream[(K, V), W]): 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: Stream[K, W]): W[Level0Meter]

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

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

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

def reverse: Map[K, V, W]

def size: W[Int]

def sizeOfBloomFilterEntries: W[Int]

def sizeOfSegments: Long