Set

Instance Constructors

new Set(core: Core[T], from: Option[From[A]], reverseIteration: Boolean = false)(implicit serializer: Serializer[A], tag: Tag[T])

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 add(elems: Iterable[A]): T[Done]
def add(elems: Stream[A, T]): T[Done]
def add(elems: A*): T[Done]
def add(elem: A, expireAfter: FiniteDuration): T[Done]
def add(elem: A, expireAt: Deadline): T[Done]
def add(elem: A): T[Done]
def after(key: A): Set[A, F, T]
def applyFunction(elem: A, function: F with GetKey[A, Nothing]): T[Done]
def applyFunction(from: A, to: A, function: F with GetKey[A, Nothing]): T[Done]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asScala: scala.collection.mutable.Set[A]
def before(key: A): Set[A, F, T]
def clear(): T[Done]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def close(): T[Unit]
def commit(prepare: Iterable[Prepare[A, Nothing]]): T[Done]
def commit(prepare: Stream[Prepare[A, Nothing], T]): T[Done]
def commit(prepare: Prepare[A, Nothing]*): T[Done]
def contains(elem: A): T[Boolean]
def delete(): T[Unit]
def drop(count: Int): Stream[A, T]

Definition Classes
Set → Streamable
def dropWhile(f: (A) ⇒ Boolean): Stream[A, T]

Definition Classes
Set → Streamable
def elemSize(elem: A): Int
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def expiration(elem: A): T[Option[Deadline]]
def expire(elems: Iterable[(A, Deadline)]): T[Done]
def expire(elems: Stream[(A, Deadline), T]): T[Done]
def expire(elems: (A, Deadline)*): T[Done]
def expire(from: A, to: A, at: Deadline): T[Done]
def expire(from: A, to: A, after: FiniteDuration): T[Done]
def expire(elem: A, at: Deadline): T[Done]
def expire(elem: A, after: FiniteDuration): T[Done]
def filter(f: (A) ⇒ Boolean): Stream[A, T]

Definition Classes
Set → Streamable
def filterNot(f: (A) ⇒ Boolean): Stream[A, T]

Definition Classes
Set → Streamable
def flatMap[B](f: (A) ⇒ Stream[B, T]): Stream[B, T]

Definition Classes
Set → Streamable
def foldLeft[B](initial: B)(f: (B, A) ⇒ B): T[B]

Definition Classes
Set → Streamable
def foreach[U](f: (A) ⇒ U): Stream[Unit, T]

Definition Classes
Set → Streamable
def from(key: A): Set[A, F, T]
def fromOrAfter(key: A): Set[A, F, T]
def fromOrBefore(key: A): Set[A, F, T]
def get(elem: A): T[Option[A]]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def headOption(readState: ReadState): T[Option[A]]

Attributes
protected
def headOption: T[Option[A]]

Definition Classes
Set → Streamable
def isEmpty: T[Boolean]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lastOption: T[Option[A]]

Definition Classes
Set → Streamable
def level0Meter: LevelZeroMeter
def levelMeter(levelNumber: Int): Option[LevelMeter]
def map[B](f: (A) ⇒ B): Stream[B, T]

Definition Classes
Set → Streamable
def mightContain(elem: A): T[Boolean]
def mightContainFunction(functionId: A): T[Boolean]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: T[Boolean]
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def registerFunction(function: F with GetKey[A, Nothing]): Unit
def remove(elems: Iterable[A]): T[Done]
def remove(elems: Stream[A, T]): T[Done]
def remove(elems: A*): T[Done]
def remove(from: A, to: A): T[Done]
def remove(elem: A): T[Done]
def reverse: Set[A, F, T]
def size: T[Int]

Definition Classes
Set → Streamable
def sizeOfBloomFilterEntries: T[Int]
def sizeOfSegments: Long
def stream: Stream[A, T]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(count: Int): Stream[A, T]

Definition Classes
Set → Streamable
def takeWhile(f: (A) ⇒ Boolean): Stream[A, T]

Definition Classes
Set → Streamable
def timeLeft(elem: A): T[Option[FiniteDuration]]
def toString(): String

Definition Classes
Set → AnyRef → Any
def toTag[X[_]](implicit tag: Tag[X]): Set[A, F, X]
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 wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: object Set | package swaydb

case class Set[A, F, T[_]](core: Core[T], from: Option[From[A]], reverseIteration: Boolean = false)(implicit serializer: Serializer[A], tag: Tag[T]) extends Streamable[A, T] with Product with Serializable

Instance Constructors

new Set(core: Core[T], from: Option[From[A]], reverseIteration: Boolean = false)(implicit serializer: Serializer[A], tag: Tag[T])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def add(elems: Iterable[A]): T[Done]

def add(elems: Stream[A, T]): T[Done]

def add(elems: A*): T[Done]

def add(elem: A, expireAfter: FiniteDuration): T[Done]

def add(elem: A, expireAt: Deadline): T[Done]

def add(elem: A): T[Done]

def after(key: A): Set[A, F, T]

def applyFunction(elem: A, function: F with GetKey[A, Nothing]): T[Done]

def applyFunction(from: A, to: A, function: F with GetKey[A, Nothing]): T[Done]

final def asInstanceOf[T0]: T0

def asScala: scala.collection.mutable.Set[A]

def before(key: A): Set[A, F, T]

def clear(): T[Done]

def clone(): AnyRef

def close(): T[Unit]

def commit(prepare: Iterable[Prepare[A, Nothing]]): T[Done]

def commit(prepare: Stream[Prepare[A, Nothing], T]): T[Done]

def commit(prepare: Prepare[A, Nothing]*): T[Done]

def contains(elem: A): T[Boolean]

def delete(): T[Unit]

def drop(count: Int): Stream[A, T]

def dropWhile(f: (A) ⇒ Boolean): Stream[A, T]

def elemSize(elem: A): Int

final def eq(arg0: AnyRef): Boolean

def expiration(elem: A): T[Option[Deadline]]

def expire(elems: Iterable[(A, Deadline)]): T[Done]

def expire(elems: Stream[(A, Deadline), T]): T[Done]

def expire(elems: (A, Deadline)*): T[Done]

def expire(from: A, to: A, at: Deadline): T[Done]

def expire(from: A, to: A, after: FiniteDuration): T[Done]

def expire(elem: A, at: Deadline): T[Done]

def expire(elem: A, after: FiniteDuration): T[Done]

def filter(f: (A) ⇒ Boolean): Stream[A, T]

def filterNot(f: (A) ⇒ Boolean): Stream[A, T]

def flatMap[B](f: (A) ⇒ Stream[B, T]): Stream[B, T]

def foldLeft[B](initial: B)(f: (B, A) ⇒ B): T[B]

def foreach[U](f: (A) ⇒ U): Stream[Unit, T]

def from(key: A): Set[A, F, T]

def fromOrAfter(key: A): Set[A, F, T]

def fromOrBefore(key: A): Set[A, F, T]

def get(elem: A): T[Option[A]]

final def getClass(): Class[_]

def headOption(readState: ReadState): T[Option[A]]

def headOption: T[Option[A]]

def isEmpty: T[Boolean]

final def isInstanceOf[T0]: Boolean

def lastOption: T[Option[A]]

def level0Meter: LevelZeroMeter

def levelMeter(levelNumber: Int): Option[LevelMeter]

def map[B](f: (A) ⇒ B): Stream[B, T]

def mightContain(elem: A): T[Boolean]

def mightContainFunction(functionId: A): T[Boolean]

final def ne(arg0: AnyRef): Boolean

def nonEmpty: T[Boolean]

final def notify(): Unit

final def notifyAll(): Unit

def registerFunction(function: F with GetKey[A, Nothing]): Unit

def remove(elems: Iterable[A]): T[Done]

def remove(elems: Stream[A, T]): T[Done]

def remove(elems: A*): T[Done]

def remove(from: A, to: A): T[Done]

def remove(elem: A): T[Done]

def reverse: Set[A, F, T]

def size: T[Int]

def sizeOfBloomFilterEntries: T[Int]

def sizeOfSegments: Long

def stream: Stream[A, T]

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

def take(count: Int): Stream[A, T]

def takeWhile(f: (A) ⇒ Boolean): Stream[A, T]

def timeLeft(elem: A): T[Option[FiniteDuration]]