PersistentMap

Instance Constructors

new PersistentMap(path: Path, mmap: data.config.MMAP.Map, fileSize: Long, flushOnOverflow: Boolean, _skipList: SkipListConcurrent[OK, OV, K, V], currentFile: DBFile, hasRangeInitial: Boolean)(implicit keyOrder: KeyOrder[K], timeOrder: TimeOrder[Slice[Byte]], fileSweeper: FileSweeperActor, bufferCleaner: ByteBufferSweeperActor, functionStore: FunctionStore, writer: MapEntryWriter[Put[K, V]], skipListMerger: SkipListMerger[OK, OV, K, V])

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asScala: scala.collection.mutable.Map[K, V]

Definition Classes
SkipListBase → SkipList
implicit val bufferCleaner: ByteBufferSweeperActor
def ceiling(key: K): OV

Definition Classes
SkipListBase → SkipList
def ceilingKey(key: K): OK

Definition Classes
SkipListBase → SkipList
def clear(): Unit

Definition Classes
SkipListBase → SkipList
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit

Definition Classes
PersistentMap → Map
def contains(key: K): Boolean

Definition Classes
SkipListBase → SkipList
def count(): Int

Definition Classes
SkipListBase → SkipList
def currentFilePath: Path
def delete: Unit

Definition Classes
PersistentMap → Map
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def exists: Boolean

Definition Classes
PersistentMap → Map
val fileSize: Long

Definition Classes
PersistentMap → Map
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def floor(key: K): OV

Definition Classes
SkipListBase → SkipList
def floorKeyValue(key: K): Option[(K, V)]

Definition Classes
SkipListBase → SkipList
val flushOnOverflow: Boolean
def foldLeft[R](r: R)(f: (R, (K, V)) ⇒ R): R

Definition Classes
SkipListBase → SkipList
def foreach[R](f: (K, V) ⇒ R): Unit

Definition Classes
SkipListBase → SkipList
def get(key: K): OV

Definition Classes
SkipListBase → SkipList
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hasRange: Boolean

Definition Classes
PersistentMap → Map
def head(): OV

Definition Classes
SkipListBase → SkipList
def headKey: OK

Definition Classes
SkipListBase → SkipList
def headKeyOrNull: K

Definition Classes
SkipListBase
def headKeyValue: Option[(K, V)]

Definition Classes
SkipListBase → SkipList
def higher(key: K): OV

Definition Classes
SkipListBase → SkipList
def higherKey(key: K): OK

Definition Classes
SkipListBase → SkipList
def higherKeyValue(key: K): Option[(K, V)]

Definition Classes
SkipListBase → SkipList
def isEmpty: Boolean

Definition Classes
SkipListBase → SkipList
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def keys(): NavigableSet[K]

Definition Classes
SkipListBase → SkipList
def last(): OV

Definition Classes
SkipListBase → SkipList
def lastKey: OK

Definition Classes
SkipListBase → SkipList
def lastKeyOrNull: K

Definition Classes
SkipListBase
def lastKeyValue: Option[(K, V)]

Definition Classes
SkipListBase
lazy val logger: Logger

Attributes
protected
Definition Classes
LazyLogging
def lower(key: K): OV

Definition Classes
SkipListBase → SkipList
def lowerKey(key: K): OK

Definition Classes
SkipListBase → SkipList
val mmap: data.config.MMAP.Map
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: Boolean

Definition Classes
SkipListBase → SkipList
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def nullKey: OK

Definition Classes
PersistentMap → SkipList
def nullValue: OV

Definition Classes
PersistentMap → SkipList
val path: Path
def pathOption: Option[Path]

Definition Classes
PersistentMap → Map
def pollFirstEntry(): Entry[K, V]

Definition Classes
SkipListBase
def pollLastEntry(): Entry[K, V]

Definition Classes
SkipListBase
def put(key: K, value: V): Unit

Definition Classes
SkipListBase → SkipList
def putIfAbsent(key: K, value: V): Boolean

returns
true

Definition Classes
SkipListBase → SkipList
def remove(key: K): Unit

Definition Classes
SkipListBase → SkipList
def size: Int

Definition Classes
SkipListBase → SkipList
def skipList: ConcurrentSkipListMap[K, V]

Attributes
protected
Definition Classes
PersistentMap → SkipListBase
var skipListKeyValuesMaxCount: Int

Definition Classes
PersistentMap → Map
def subMap(from: K, fromInclusive: Boolean, to: K, toInclusive: Boolean): NavigableMap[K, V]

Definition Classes
SkipListBase → SkipList
def subMap(from: K, to: K): NavigableMap[K, V]

Definition Classes
SkipListBase → SkipList
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(count: Int): Slice[V]

Definition Classes
SkipListBase → SkipList
final def toOptionKey(key: K): OK

Definition Classes
SkipList
Annotations
@inline()
final def toOptionKeyValue(entry: Entry[K, V]): Option[(K, V)]

Definition Classes
SkipList
Annotations
@inline()
final def toOptionValue(value: V): OV

Definition Classes
SkipList
Annotations
@inline()
final def toOptionValue(entry: Entry[K, V]): OV

Definition Classes
SkipList
Annotations
@inline()
def toSlice[V2 >: V](size: Int)(implicit arg0: ClassTag[V2]): Slice[V2]

Definition Classes
SkipListBase
final def tryOptionKey(block: ⇒ K): OK

Definition Classes
SkipList
Annotations
@inline()
final def tryOptionKeyValue(block: ⇒ Entry[K, V]): Option[(K, V)]

Definition Classes
SkipList
Annotations
@inline()
final def tryOptionValue(block: ⇒ Entry[K, V]): OV

Definition Classes
SkipList
Annotations
@inline()
val uniqueFileNumber: Long

Definition Classes
PersistentMap → Map
def values(): Collection[V]

Definition Classes
SkipListBase → SkipList
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( ... )
final def writeNoSync(entry: MapEntry[K, V]): Boolean

Before writing the Entry, check to ensure if the current MapEntry requires a merge write or direct write.
Before writing the Entry, check to ensure if the current MapEntry requires a merge write or direct write.
Merge write should be used when - The entry contains a swaydb.core.data.Memory.Range key-value. - The entry contains a swaydb.core.data.Memory.Update Update key-value. - The entry contains a swaydb.core.data.Memory.Remove with deadline key-value. Removes without deadlines do not require merging.
Note: These check are not required for Appendix writes because Appendix entries current do not use Range, Update or key-values with deadline.

Definition Classes
PersistentMap → Map
Annotations
@tailrec()
def writeSafe[E](mapEntry: MapEntry[K, V])(implicit arg0: ExceptionHandler[E]): IO[E, Boolean]

Definition Classes
Map
def writeSync(mapEntry: MapEntry[K, V]): Boolean

Definition Classes
PersistentMap → Map

Related Doc: package map

Instance Constructors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def asScala: scala.collection.mutable.Map[K, V]

implicit val bufferCleaner: ByteBufferSweeperActor

def ceiling(key: K): OV

def ceilingKey(key: K): OK

def clear(): Unit

def clone(): AnyRef

def close(): Unit

def contains(key: K): Boolean

def count(): Int

def currentFilePath: Path

def delete: Unit

final def eq(arg0: AnyRef): Boolean

def exists: Boolean

val fileSize: Long

def finalize(): Unit

def floor(key: K): OV

def floorKeyValue(key: K): Option[(K, V)]

val flushOnOverflow: Boolean

def foldLeft[R](r: R)(f: (R, (K, V)) ⇒ R): R

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

def get(key: K): OV

final def getClass(): Class[_]

def hasRange: Boolean

def head(): OV

def headKey: OK

def headKeyOrNull: K

def headKeyValue: Option[(K, V)]

def higher(key: K): OV

def higherKey(key: K): OK

def higherKeyValue(key: K): Option[(K, V)]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def keys(): NavigableSet[K]

def last(): OV

def lastKey: OK

def lastKeyOrNull: K

def lastKeyValue: Option[(K, V)]

lazy val logger: Logger

def lower(key: K): OV

def lowerKey(key: K): OK

val mmap: data.config.MMAP.Map

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def nullKey: OK

def nullValue: OV

val path: Path

def pathOption: Option[Path]

def pollFirstEntry(): Entry[K, V]

def pollLastEntry(): Entry[K, V]

def put(key: K, value: V): Unit

def putIfAbsent(key: K, value: V): Boolean

def remove(key: K): Unit

def size: Int

def skipList: ConcurrentSkipListMap[K, V]

var skipListKeyValuesMaxCount: Int

def subMap(from: K, fromInclusive: Boolean, to: K, toInclusive: Boolean): NavigableMap[K, V]

def subMap(from: K, to: K): NavigableMap[K, V]

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

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

final def toOptionKey(key: K): OK

final def toOptionKeyValue(entry: Entry[K, V]): Option[(K, V)]

final def toOptionValue(value: V): OV

final def toOptionValue(entry: Entry[K, V]): OV

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

final def tryOptionKey(block: ⇒ K): OK

final def tryOptionKeyValue(block: ⇒ Entry[K, V]): Option[(K, V)]

final def tryOptionValue(block: ⇒ Entry[K, V]): OV

val uniqueFileNumber: Long

def values(): Collection[V]

final def wait(): Unit