case class Map[K, V, F, BAG[_]](core: Core[BAG], from: Option[From[K]] = None, reverseIteration: Boolean = false)(implicit keySerializer: Serializer[K], valueSerializer: Serializer[V], bag: Bag[BAG]) extends Product with Serializable
Map database API.
For documentation check - http://swaydb.io/bag/
- Self Type
- Map[K, V, F, BAG]
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- Map
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Instance Constructors
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, F, BAG]
- def applyFunction[PF <: F](from: K, to: K, function: PF)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- def applyFunction[PF <: F](key: K, function: PF)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asScala: scala.collection.mutable.Map[K, V]
- def before(key: K): Map[K, V, F, BAG]
- def clear(): BAG[OK]
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def close(): BAG[Unit]
- def commit[PF <: F](prepare: Iterable[Prepare[K, V, PF]])(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- def commit[PF <: F](prepare: Stream[Prepare[K, V, PF]])(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- def commit[PF <: F](prepare: Prepare[K, V, PF]*)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- def contains(key: K): BAG[Boolean]
- def delete(): BAG[Unit]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def expiration(key: K): BAG[Option[Deadline]]
- def expire(keys: Iterator[(K, Deadline)]): BAG[OK]
- def expire(keys: Iterable[(K, Deadline)]): BAG[OK]
- def expire(keys: Stream[(K, Deadline)]): BAG[OK]
- def expire(keys: (K, Deadline)*): BAG[OK]
- def expire(from: K, to: K, at: Deadline): BAG[OK]
- def expire(from: K, to: K, after: FiniteDuration): BAG[OK]
- def expire(key: K, at: Deadline): BAG[OK]
- def expire(key: K, after: FiniteDuration): BAG[OK]
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def from(key: K): Map[K, V, F, BAG]
- def fromOrAfter(key: K): Map[K, V, F, BAG]
- def fromOrBefore(key: K): Map[K, V, F, BAG]
-
def
get(key: K): BAG[Option[V]]
Returns target value for the input key.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
getKey(key: K): BAG[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): BAG[Option[(K, V)]]
- def headOption: BAG[Option[(K, V)]]
- def isEmpty: BAG[Boolean]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterator[BAG[_]](implicit bag: Sync[BAG]): Iterator[BAG[(K, V)]]
- def keySize(key: K): Int
- def keys: Set[K, F, BAG]
- def lastOption: BAG[Option[(K, V)]]
- def levelMeter(levelNumber: Int): Option[LevelMeter]
- def levelZeroMeter: LevelZeroMeter
- def mightContain(key: K): BAG[Boolean]
- def mightContainFunction(functionId: K): BAG[Boolean]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonEmpty: BAG[Boolean]
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def put(keyValues: Iterator[(K, V)]): BAG[OK]
- def put(keyValues: Iterable[(K, V)]): BAG[OK]
- def put(keyValues: Stream[(K, V)]): BAG[OK]
- def put(keyValues: (K, V)*): BAG[OK]
- def put(key: K, value: V, expireAt: Deadline): BAG[OK]
- def put(key: K, value: V, expireAfter: FiniteDuration): BAG[OK]
- def put(key: K, value: V): BAG[OK]
- def registerFunction[PF <: F](function: PF)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- def remove(keys: Iterator[K]): BAG[OK]
- def remove(keys: Iterable[K]): BAG[OK]
- def remove(keys: Stream[K]): BAG[OK]
- def remove(keys: K*): BAG[OK]
- def remove(from: K, to: K): BAG[OK]
- def remove(key: K): BAG[OK]
- def reverse: Map[K, V, F, BAG]
- def sizeOfBloomFilterEntries: BAG[Int]
- def sizeOfSegments: Long
- def stream: Stream[(K, V)]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def timeLeft(key: K): BAG[Option[FiniteDuration]]
-
def
toBag[X[_]](implicit bag: Bag[X]): Map[K, V, F, X]
Returns an Async API of type O where the Bag is known.
-
def
toString(): String
- Definition Classes
- Map → AnyRef → Any
- def update(keyValues: Iterator[(K, V)]): BAG[OK]
- def update(keyValues: Iterable[(K, V)]): BAG[OK]
- def update(keyValues: Stream[(K, V)]): BAG[OK]
- def update(keyValues: (K, V)*): BAG[OK]
- def update(from: K, to: K, value: V): BAG[OK]
- def update(key: K, value: V): BAG[OK]
- def valueSize(value: V): Int
-
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( ... ) @native()