MapIterator

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: (K, V), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def ++:[B >: (K, V), That](that: Traversable[B])(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def ++:[B >: (K, V), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def /:[B](z: B)(op: (B, (K, V)) ⇒ B): B

def :\[B](z: B)(op: ((K, V), B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def after(key: K): MapIterator[K, V]

def aggregate[B](z: ⇒ B)(seqop: (B, (K, V)) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def before(key: K): MapIterator[K, V]

def canEqual(that: Any): Boolean

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[(K, V), B])(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def collectFirst[B](pf: PartialFunction[(K, V), B]): Option[B]

def companion: GenericCompanion[Iterable]

def copyToArray[B >: (K, V)](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: (K, V)](xs: Array[B]): Unit

def copyToArray[B >: (K, V)](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: (K, V)](dest: Buffer[B]): Unit

def count(p: ((K, V)) ⇒ Boolean): Int

val dbIterator: swaydb.Map[Key[K], Option[V]]

def drop(n: Int): Iterable[(K, V)]

def dropRight(n: Int): Iterable[(K, V)]

def dropWhile(p: ((K, V)) ⇒ Boolean): Iterable[(K, V)]

final def eq(arg0: AnyRef): Boolean

def exists(p: ((K, V)) ⇒ Boolean): Boolean

def filter(p: ((K, V)) ⇒ Boolean): Iterable[(K, V)]

def filterNot(p: ((K, V)) ⇒ Boolean): Iterable[(K, V)]

def find(p: ((K, V)) ⇒ Boolean): Option[(K, V)]

def flatMap[B, That](f: ((K, V)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def flatten[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): Iterable[B]

def fold[A1 >: (K, V)](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, (K, V)) ⇒ B): B

def foldRight[B](b: B)(op: ((K, V), B) ⇒ B): B

def forall(p: ((K, V)) ⇒ Boolean): Boolean

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

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

def from(key: K): MapIterator[K, V]

def fromOrAfter(key: K): MapIterator[K, V]

def fromOrBefore(key: K): MapIterator[K, V]

def genericBuilder[B]: Builder[B, Iterable[B]]

final def getClass(): Class[_]

def groupBy[K](f: ((K, V)) ⇒ K): scala.collection.immutable.Map[K, Iterable[(K, V)]]

def grouped(size: Int): Iterator[Iterable[(K, V)]]

def hasDefiniteSize: Boolean

def head: (K, V)

def headOption: Option[(K, V)]

def init: Iterable[(K, V)]

def inits: Iterator[Iterable[(K, V)]]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isTraversableAgain: Boolean

def iterator: Iterator[(K, V)]

def last: (K, V)

def lastOption: Option[(K, V)]

lastOption should always force formKey to be the endSubMapsKey because from is always set in swaydb.extension.Maps and regardless from where the iteration starts the most efficient way to fetch the last is from the key endSubMapsKey.

def map[B, That](f: ((K, V)) ⇒ B)(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

val mapKey: Seq[K]

def mapRight[B, T](f: (K, V) ⇒ B)(implicit bf: CanBuildFrom[Iterable[(K, V)], B, T]): T

val mapsOnly: Boolean

def max[B >: (K, V)](implicit cmp: Ordering[B]): (K, V)

def maxBy[B](f: ((K, V)) ⇒ B)(implicit cmp: Ordering[B]): (K, V)

def min[B >: (K, V)](implicit cmp: Ordering[B]): (K, V)

def minBy[B](f: ((K, V)) ⇒ B)(implicit cmp: Ordering[B]): (K, V)

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[(K, V), Iterable[(K, V)]]

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def par: ParIterable[(K, V)]

def parCombiner: Combiner[(K, V), ParIterable[(K, V)]]

def partition(p: ((K, V)) ⇒ Boolean): (Iterable[(K, V)], Iterable[(K, V)])

def product[B >: (K, V)](implicit num: Numeric[B]): B

def reduce[A1 >: (K, V)](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: (K, V)](op: (B, (K, V)) ⇒ B): B

def reduceLeftOption[B >: (K, V)](op: (B, (K, V)) ⇒ B): Option[B]

def reduceOption[A1 >: (K, V)](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: (K, V)](op: ((K, V), B) ⇒ B): B

def reduceRightOption[B >: (K, V)](op: ((K, V), B) ⇒ B): Option[B]

def repr: Iterable[(K, V)]

def reversed: List[(K, V)]

def sameElements[B >: (K, V)](that: GenIterable[B]): Boolean

def scan[B >: (K, V), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def scanLeft[B, That](z: B)(op: (B, (K, V)) ⇒ B)(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def scanRight[B, That](z: B)(op: ((K, V), B) ⇒ B)(implicit bf: CanBuildFrom[Iterable[(K, V)], B, That]): That

def seq: Iterable[(K, V)]

def size: Int

def slice(from: Int, until: Int): Iterable[(K, V)]

def sliding(size: Int, step: Int): Iterator[Iterable[(K, V)]]

def sliding(size: Int): Iterator[Iterable[(K, V)]]

def span(p: ((K, V)) ⇒ Boolean): (Iterable[(K, V)], Iterable[(K, V)])

def splitAt(n: Int): (Iterable[(K, V)], Iterable[(K, V)])

def stringPrefix: String

def sum[B >: (K, V)](implicit num: Numeric[B]): B

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

def tail: Iterable[(K, V)]

def tails: Iterator[Iterable[(K, V)]]

def take(n: Int): Iterable[(K, V)]

def takeRight(n: Int): Iterable[(K, V)]

def takeWhile(p: ((K, V)) ⇒ Boolean): Iterable[(K, V)]

def thisCollection: Iterable[(K, V)]

def till(condition: (K, V) ⇒ Boolean): MapIterator[K, V]

val till: (K, V) ⇒ Boolean

def tillKey(condition: (K) ⇒ Boolean): MapIterator[K, V]

def tillValue(condition: (V) ⇒ Boolean): MapIterator[K, V]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (K, V), Col[(K, V)]]): Col[(K, V)]

def toArray[B >: (K, V)](implicit arg0: ClassTag[B]): Array[B]

def toBuffer[B >: (K, V)]: Buffer[B]

def toCollection(repr: Iterable[(K, V)]): Iterable[(K, V)]

def toIndexedSeq: IndexedSeq[(K, V)]

def toIterable: Iterable[(K, V)]

def toIterator: Iterator[(K, V)]

def toList: List[(K, V)]

def toMap[T, U](implicit ev: <:<[(K, V), (T, U)]): scala.collection.immutable.Map[T, U]

def toSeq: Seq[(K, V)]

def toSet[B >: (K, V)]: scala.collection.immutable.Set[B]

def toStream: Stream[(K, V)]

def toString(): String

def toTraversable: Traversable[(K, V)]

def toVector: Vector[(K, V)]

def transpose[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]

def unzip[A1, A2](implicit asPair: ((K, V)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

val userDefinedFrom: Boolean

def view(from: Int, until: Int): IterableView[(K, V), Iterable[(K, V)]]

def view: IterableView[(K, V), Iterable[(K, V)]]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def withFilter(p: ((K, V)) ⇒ Boolean): FilterMonadic[(K, V), Iterable[(K, V)]]

def zip[A1 >: (K, V), B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Iterable[(K, V)], (A1, B), That]): That

def zipAll[B, A1 >: (K, V), That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Iterable[(K, V)], (A1, B), That]): That

def zipWithIndex[A1 >: (K, V), That](implicit bf: CanBuildFrom[Iterable[(K, V)], (A1, Int), That]): That

def finalize(): Unit