case class MultiMap[M, K, V, F, BAG[_]] extends MapT[K, V, F, BAG] with Product with Serializable
MultiMap extends swaydb.Map's API to allow storing multiple Maps withing a single Map.
MultiMap is just a simple extension that uses custom data types (MultiKey) and KeyOrder (MultiKey.ordering) for it's API.
- Self Type
- MultiMap[M, K, V, F, BAG]
- Alphabetic
- By Inheritance
- MultiMap
- Serializable
- Serializable
- Product
- Equals
- MapT
- SetMapT
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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
applyFunction[PF <: F](from: K, to: K, function: PF)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- Definition Classes
- MultiMap → MapT
- Note
In other operations like expire, remove, put the input expiration value is compared with defaultExpiration to get the nearest expiration. But functions does not check if the custom logic within the function expires key-values earlier than defaultExpiration.
-
def
applyFunction[PF <: F](key: K, function: PF)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[OK]
- Definition Classes
- MultiMap → MapT
- Note
In other operations like expire, remove, put the input expiration value is compared with defaultExpiration to get the nearest expiration. But functions does not check if the custom logic within the function expires key-values earlier than defaultExpiration.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asScala: scala.collection.mutable.Map[K, V]
- implicit val bag: Bag[BAG]
- def clearKeyValues(): 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], BAG])(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
commit[M2, K2, V2, PF <: F](transaction: Iterable[Transaction[M, K, V, PF]])(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]], evT: <:<[M2, M], evK: <:<[K2, K], evV: <:<[V2, V]): BAG[OK]
Commits transaction to global map.
- def contains(key: K): BAG[Boolean]
- val defaultExpiration: Option[Deadline]
- 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]): 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
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.
- def getKeyDeadline[BAG[_]](key: K, bag: Bag[BAG]): BAG[Option[(K, Option[Deadline])]]
- def getKeyDeadline(key: K): BAG[Option[(K, Option[Deadline])]]
- def getKeyValue(key: K): BAG[Option[(K, V)]]
- def getKeyValueDeadline[BAG[_]](key: K, bag: Bag[BAG]): BAG[Option[((K, Option[Deadline]), V)]]
- def headOption: BAG[Option[(K, V)]]
- def headOrNull: BAG[(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 lastOption: BAG[Option[(K, V)]]
- def levelMeter(levelNumber: Int): Option[LevelMeter]
- def levelZeroMeter: LevelZeroMeter
- val mapId: Long
- val mapKey: M
- def mightContain(key: K): BAG[Boolean]
- def mightContainFunction[PF <: F](function: PF)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[Boolean]
-
def
narrow[M2, K2, V2, F2](mapKey: Class[M2], keyType: Class[K2], valueType: Class[V2], functionType: Class[F2])(implicit evT: <:<[M2, M], evK: <:<[K2, K], evV: <:<[V2, V], evF: <:<[F2, F]): MultiMap[M2, K2, V2, F2, BAG]
Narrows this MultiMap's map key type M, key-value key type K, value type V and function type F.
-
def
narrow[M2, K2, V2](mapKey: Class[M2], keyType: Class[K2], valueType: Class[V2])(implicit evT: <:<[M2, M], evK: <:<[K2, K], evV: <:<[V2, V]): MultiMap[M2, K2, V2, F, BAG]
Narrows this MultiMap's map key type M, key-value key type K and value type V
-
def
narrow[M2, K2](mapKey: Class[M2], keyType: Class[K2])(implicit evT: <:<[M2, M], evK: <:<[K2, K]): MultiMap[M2, K2, V, F, BAG]
Narrows this MultiMap's map key type M and key-value key type K
-
def
narrow[M2](mapKey: Class[M2])(implicit evT: <:<[M2, M]): MultiMap[M2, K, V, F, BAG]
Narrows this MultiMap's map key type M
-
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 path: Path
- def put(keyValues: Iterator[(K, V)]): BAG[OK]
- def put(keyValues: Iterable[(K, V)]): BAG[OK]
- def put(keyValues: Stream[(K, V), BAG]): 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
put(key: K, value: V, expireAt: Option[Deadline]): BAG[OK]
- Definition Classes
- SetMapT
- def remove(keys: Iterator[K]): BAG[OK]
- def remove(keys: Iterable[K]): BAG[OK]
- def remove(keys: Stream[K, BAG]): BAG[OK]
- def remove(keys: K*): BAG[OK]
- def remove(from: K, to: K): BAG[OK]
- def remove(key: K): BAG[OK]
-
val
schema: Schema[M, K, V, F, BAG]
APIs for managing child map of this MultiMap.
- def sizeOfBloomFilterEntries: BAG[Int]
- def sizeOfSegments: Long
- def stream: Source[K, (K, V), BAG]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def timeLeft(key: K): BAG[Option[FiniteDuration]]
-
def
toBag[X[_]](implicit bag: Bag[X]): MultiMap[M, K, V, F, X]
Returns an Async API of type O where the Bag is known.
- def toString(): String
-
def
toTransaction[PF <: F](prepare: Iterable[Prepare[K, V, PF]])(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): Iterable[Transaction[M, K, V, PF]]
Converts Prepare statement for this map into Prepare statement for this Map's parent Map so that multiple MultiMap Prepare statements can be executed as a single transaction.
Converts Prepare statement for this map into Prepare statement for this Map's parent Map so that multiple MultiMap Prepare statements can be executed as a single transaction.
- See also
MultiMap.commit to commit Transactions.
-
def
toTransaction[PF <: F](prepare: Stream[Prepare[K, V, PF], BAG])(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): BAG[Iterable[Transaction[M, K, V, PF]]]
Converts Prepare statement for this map into Prepare statement for this Map's parent Map so that multiple MultiMap Prepare statements can be executed as a single transaction.
Converts Prepare statement for this map into Prepare statement for this Map's parent Map so that multiple MultiMap Prepare statements can be executed as a single transaction.
- See also
MultiMap.commit to commit Transactions.
-
def
toTransaction[PF <: F](prepare: Prepare[K, V, PF]*)(implicit ev: <:<[PF, PureFunction[K, V, Apply.Map[V]]]): Seq[Transaction[M, K, V, PF]]
Converts Prepare statement for this map into Prepare statement for this Map's parent Map so that multiple MultiMap Prepare statements can be executed as a single transaction.
Converts Prepare statement for this map into Prepare statement for this Map's parent Map so that multiple MultiMap Prepare statements can be executed as a single transaction.
- See also
MultiMap.commit to commit Transactions.
- def update(keyValues: Iterator[(K, V)]): BAG[OK]
- def update(keyValues: Iterable[(K, V)]): BAG[OK]
- def update(keyValues: Stream[(K, V), BAG]): 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()