LArray

abstract def address: Long

Raw-memory address of this array

abstract def apply(i: Long): A

Retrieve an element at the given index.

abstract def clear(): Unit

Clear the contents of the array.

abstract def copyTo[B](srcOffset: Long, dst: RawByteArray[B], dstOffset: Long, blen: Long): Unit

Copy the contents of this sequence into the target LByteArray

abstract def copyTo(dst: LByteArray, dstOffset: Long): Unit

Copy the contents of this LSeq[A] into the target LByteArray

abstract def free: Unit

Release the memory of LArray.

abstract def newBuilder: LBuilder[A, Repr]

abstract def size: Long

Element size of this array

abstract def update(i: Long, v: A): A

Update an element

abstract def view(from: Long, to: Long): LArrayView[A]

Create a shallow copy (view) of LArray

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: LSeq[A]): Repr

Create a new array that concatenates two arrays

def +:(elem: A): Repr

Copy of thie array with an element prepended.

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

fold left

def :+(elem: A): Repr

Copy of this array with an element appended.

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

fold right

final def ==(arg0: Any): Boolean

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

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

final def asInstanceOf[T0]: T0

def byteLength: Long

Byte length of this array.

def clone(): AnyRef

def close(): Unit

def collect[B](pf: PartialFunction[A, B]): LIterator[B]

Builds a new collection by applying a partial function to all elments of this array on which the function is defined.

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

Finds the first element of this array on which the given partial function is defined, and applies the partial function to it.

def concat(other: LSeq[A]): Repr

Create a new array that concatenates two arrays

def contains(elem: A): Boolean

def copyToArray[B >: A](xs: LArray[B], start: Long, len: Long): Unit

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

def drop(n: Long): Repr

def dropWhile(p: (A) ⇒ Boolean): Repr

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (A) ⇒ Boolean): Boolean

def filter(pred: (A) ⇒ Boolean): LIterator[A]

def filterNot(pred: (A) ⇒ Boolean): LIterator[A]

def finalize(): Unit

def find(p: (A) ⇒ Boolean): Option[A]

def flatMap[B](f: (A) ⇒ LIterator[B]): LIterator[B]

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

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

def foldRight[B](z: B)(op: (A, B) ⇒ B): B

def forall(p: (A) ⇒ Boolean): Boolean

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

def getByte(offset: Long): Byte

def getChar(offset: Long): Char

final def getClass(): Class[_]

def getDouble(offset: Long): Double

def getFloat(offset: Long): Float

def getInt(offset: Long): Int

def getLong(offset: Long): Long

def getShort(offset: Long): Short

def hashCode(): Int

def head: A

def indexOf[B >: A](elem: B): Long

def indexWhere(p: (A) ⇒ Boolean, from: Long): Long

def init: Repr

def isEmpty: Boolean

Tests whether this sequence is empty

final def isInstanceOf[T0]: Boolean

def isOpen(): Boolean

def iterator: LIterator[A]

Creates a new iterator over all elements contained in this collection

def ji: Iterable[A]

Provides the Iterable interface for Java

def last: A

def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int

def length: Long

def map[B](f: (A) ⇒ B): LIterator[B]

def mkString: String

def mkString(sep: String): String

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def partition(p: (A) ⇒ Boolean): (LIterator[A], LIterator[A])

def prefixLength(p: (A) ⇒ Boolean): Long

def putByte(offset: Long, v: Byte): Byte

def putChar(offset: Long, v: Char): Char

def putDouble(offset: Long, v: Double): Double

def putFloat(offset: Long, v: Float): Float

def putInt(offset: Long, v: Int): Int

def putLong(offset: Long, v: Long): Long

def putShort(offset: Long, v: Short): Short

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

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

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

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

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

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

def release: Unit

Release the memory of LArray.

def reverse[A]: Repr

def reverseIterator: LIterator[A]

def sameElements[B >: A](that: LIterable[B]): Boolean

def saveTo(f: File): File

Save to a file.

def scanLeft[B](z: B)(op: (B, A) ⇒ B): LIterator[B]

def segmentLength(p: (A) ⇒ Boolean, from: Long): Long

def slice(from: Long, until: Long): LArray[A]

def slice(from: Long): LArray[A]

def sliding(size: Long, step: Long): LIterator[Repr]

Groups elemnts in fixed size blocks by passing a 'sliding window' over them.

def sliding(size: Int): LIterator[Repr]

Groups elements in fixed size blocks by passing a 'sliding window' over them

def span(p: (A) ⇒ Boolean): (Repr, Repr)

def splitAt(n: Long): (Repr, Repr)

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

def tail: LArray[A]

def take(n: Long): Repr

def takeRight(n: Long): Repr

def takeWhile(p: (A) ⇒ Boolean): Repr

def toArray[A1 >: A](implicit arg0: ClassTag[A1]): Array[A1]

Creates a copy of this array in the form of the standard Scala Array

def toDirectByteBuffer: Array[ByteBuffer]

Create a sequence of DirectByteBuffer that projects LArray contents

def toIterator: LIterator[A]

def toLSeq: LSeq[A]

Wraps with immutable interface

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (A) ⇒ Boolean): LIterator[A]

def write(src: ByteBuffer): Int

Write the contents of ByteBuffer to this array.

def zip[B](that: LIterable[B]): LIterator[(A, B)]

def zipAll[B, A1 >: A, B1 >: B](that: LIterable[B], thisElem: A1, thatElem: B1): LIterator[(A1, B1)]

def zipWithIndex: LIterator[(A, Long)]