SkipListBatchable

abstract def cloneInstance(skipList: SL): SkipListBatchable[OptionKey, OptionValue, Key, Value, SL]

abstract def nullKey: OptionKey

abstract def nullValue: OptionValue

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def asScala: Map[Key, Value]

def batch(batches: Iterable[Batch[Key, Value]]): Unit

Does not support concurrent batch writes since it's only being used by swaydb.core.level.Level which write to appendix concurrently.

def ceiling(key: Key): OptionValue

def ceilingKey(key: Key): OptionKey

def clear(): Unit

def clone(): AnyRef

def contains(key: Key): Boolean

def count(): Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def floor(key: Key): OptionValue

def floorKeyValue(key: Key): Option[(Key, Value)]

def foldLeft[R](r: R)(f: (R, (Key, Value)) ⇒ R): R

def foreach[R](f: (Key, Value) ⇒ R): Unit

def get(key: Key): OptionValue

final def getClass(): Class[_]

def hashCode(): Int

def head(): OptionValue

def headKey: OptionKey

def headKeyOrNull: Key

def headKeyValue: Option[(Key, Value)]

def higher(key: Key): OptionValue

def higherKey(key: Key): OptionKey

def higherKeyValue(key: Key): Option[(Key, Value)]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def keys(): NavigableSet[Key]

def last(): OptionValue

def lastKey: OptionKey

def lastKeyOrNull: Key

def lastKeyValue: Option[(Key, Value)]

def lower(key: Key): OptionValue

def lowerKey(key: Key): OptionKey

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pollFirstEntry(): Entry[Key, Value]

def pollLastEntry(): Entry[Key, Value]

def put(keyValues: Iterable[(Key, Value)]): Unit

def put(key: Key, value: Value): Unit

def putIfAbsent(key: Key, value: Value): Boolean

def remove(key: Key): Unit

def size: Int

var skipList: SL

def subMap(from: Key, fromInclusive: Boolean, to: Key, toInclusive: Boolean): NavigableMap[Key, Value]

def subMap(from: Key, to: Key): NavigableMap[Key, Value]

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

def take(count: Int): Slice[Value]

final def toOptionKey(key: Key): OptionKey

final def toOptionKeyValue(entry: Entry[Key, Value]): Option[(Key, Value)]

final def toOptionValue(value: Value): OptionValue

final def toOptionValue(entry: Entry[Key, Value]): OptionValue

def toSlice[V2 >: Value](size: Int)(implicit arg0: ClassTag[V2]): Slice[V2]

def toString(): String

final def tryOptionKey(block: ⇒ Key): OptionKey

final def tryOptionKeyValue(block: ⇒ Entry[Key, Value]): Option[(Key, Value)]

final def tryOptionValue(block: ⇒ Entry[Key, Value]): OptionValue

def values(): Collection[Value]

final def wait(): Unit

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

final def wait(arg0: Long): Unit