Slice

abstract def columns: Map[ColumnRef, Column]

abstract def size: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def arraySwap(index: Int): Slice { ... /* 2 definitions in type refinement */ }

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compact(filter: Slice, definedness: Definedness): Slice

def definedAt: BitSet

def definedConst(value: CValue): Slice

def delete(jtype: JType): Slice

def deleteFields(prefixes: Set[CPathField]): Slice { ... /* 2 definitions in type refinement */ }

def deref(node: CPathNode): Slice

def distinct(prevFilter: Option[Slice], filter: Slice): Slice

Assumes that this and the previous slice (if any) are sorted.

def drop(sz: Int): Slice

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterDefined(filter: Slice, definedness: Definedness): Slice { ... /* 3 definitions in type refinement */ }

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def isDefinedAt(row: Int): Boolean

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isType(jtpe: JType): Slice

returns a BoolColumn that is true if row subsumes jtype, false otherwise (unless undefined) determine if the supplied jtype subsumes all the columns if false, return a BoolColumn with all falses, defined by union if true, collect just those columns that the jtype specifies then on a row-by-row basis, using a BitSet, we use Schema.findTypes(...) to determine the Boolean values

def logicalColumns: (JType) ⇒ Set[Column]

def map(from: CPath, to: CPath)(f: CF1): Slice

def map2(froml: CPath, fromr: CPath, to: CPath)(f: CF2): Slice

def mapColumns(f: CF1): Slice

def mapRoot(f: CF1): Slice

def materialized: Slice

This creates a new slice with the same size and columns as this slice, but whose values have been materialized and stored in arrays.

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def order: Order[Int]

def redefineWith(s: BitSet): Slice

Transform this slice such that its columns are only defined for row indices in the given BitSet.

def remap(indices: ArrayIntList): Slice { ... /* 2 definitions in type refinement */ }

def renderJson[M[+_]](delimiter: String)(implicit M: Monad[M]): (StreamT[M, CharBuffer], Boolean)

def retain(refs: Set[ColumnRef]): Slice { ... /* 2 definitions in type refinement */ }

def sortBy(prefixes: Vector[CPath], sortOrder: DesiredSortOrder = SortAscending): Slice

def sortWith(keySlice: Slice, sortOrder: DesiredSortOrder = SortAscending): (Slice, Slice)

def sparsen(index: Array[Int], toSize: Int): Slice

def split(idx: Int): (Slice, Slice)

Split the table at the specified index, exclusive.

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

def take(sz: Int): Slice

def takeRange(startIndex: Int, numberToTake: Int): Slice

def toArray[A](implicit tpe0: CValueType[A]): Slice { ... /* 6 definitions in type refinement */ }

def toJValue(row: Int): JValue

def toJson(row: Int): Option[JValue]

def toJsonElements: Vector[JValue]

def toJsonString(prefix: String = ""): String

def toRValue(row: Int): RValue

def toString(): String

def toString(row: Int): Option[String]

def typed(jtpe: JType): Slice

def typedSubsumes(jtpe: JType): Slice

lazy val valueColumns: Set[Column]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wrap(wrapper: CPathNode): Slice

def zip(other: Slice): Slice