fs2-core/fs2/Chunk$/Buffer

Buffer

sealed abstract class Buffer[A <: Buffer[A, B, C], B <: Buffer, C](buf: B, val offset: Int, val size: Int)(evidence$4: ClassTag[C]) extends Chunk[C]
class Chunk[C]
trait ChunkPlatform[C]
trait Serializable
class Object
trait Matchable
class Any

Value members

Methods

def readOnly(b: B): B
def buffer(b: B): A
def get(b: B, n: Int): C
def get(b: B, dest: Array[C], offset: Int, length: Int): B
def duplicate(b: B): B
def apply(i: Int): C
override def drop(n: Int): Chunk[C]
Definition Classes
override def take(n: Int): Chunk[C]
Definition Classes
def copyToArray[O2 >: C](xs: Array[O2], start: Int): Unit
protected def splitAtChunk_(n: Int): (A, A)
override def toArray[O2 >: C](evidence$8: ClassTag[O2]): Array[O2]
Definition Classes

Fields

val offset: Int
val size: Int

Inherited methods

def foreach(f: O => Unit): Unit
Invokes the supplied function for each element of this chunk.
Inhertied from
Chunk
def flatMap[O2](f: O => Chunk[O2]): Chunk[O2]
Maps f over the elements of this chunk and concatenates the result.
Inhertied from
Chunk
def filter(p: O => Boolean): Chunk[O]
Returns a chunk that has only the elements that satisfy the supplied predicate.
Inhertied from
Chunk
def toChain: Chain[O]
Converts this chunk to a chain.
Inhertied from
Chunk
def find(p: O => Boolean): Option[O]
Returns the first element for which the predicate returns true or None if no elements satisfy the predicate.
Inhertied from
Chunk
def toArraySeq[O2 >: O](evidence$1: ClassTag[O2]): ArraySeq[O2]
Inhertied from
ChunkPlatform
def compact[O2 >: O](ct: ClassTag[O2]): ArraySlice[O2]
Converts this chunk to a chunk backed by a single array.
Inhertied from
Chunk
def toArraySeqUntagged: ArraySeq[O]
Inhertied from
ChunkPlatform
def zip[O2](that: Chunk[O2]): Chunk[(O, O2)]
Zips this chunk the the supplied chunk, returning a chunk of tuples.
Inhertied from
Chunk
def splitAt(n: Int): (Chunk[O], Chunk[O])
Splits this chunk in to two chunks at the specified index.
Inhertied from
Chunk
def foldLeft[A](init: A)(f: (A, O) => A): A
Left-folds the elements of this chunk.
Inhertied from
Chunk
def iterator: Iterator[O]
Creates an iterator that iterates the elements of this chunk. The returned iterator is not thread safe.
Inhertied from
Chunk
def dropRight(n: Int): Chunk[O]
Drops the right-most n elements of this chunk queue in a way that preserves chunk structure.
Inhertied from
Chunk
def toArraySlice[O2 >: O](ct: ClassTag[O2]): ArraySlice[O2]
Inhertied from
Chunk
def toIArraySlice[O2 >: O](ct: ClassTag[O2]): IArraySlice[O2]
Inhertied from
ChunkPlatform
def traverse[F <: ([_$1] =>> Any), O2](f: O => F[O2])(F: Applicative[F]): F[Chunk[O2]]
Inhertied from
Chunk
def toNel: Option[NonEmptyList[O]]
Converts this chunk to a NonEmptyList
Inhertied from
Chunk
def scanLeft[O2](z: O2)(f: (O2, O) => O2): Chunk[O2]
Like foldLeft but emits each intermediate result of f.
Inhertied from
Chunk
def map[O2](f: O => O2): Chunk[O2]
Creates a new chunk by applying f to each element in this chunk.
Inhertied from
Chunk
def mapAccumulate[S, O2](init: S)(f: (S, O) => (S, O2)): (S, Chunk[O2])
Maps the supplied stateful function over each element, outputting the final state and the accumulated outputs.
The first invocation of f uses init as the input state value. Each successive invocation uses
the output state of the previous invocation.
Inhertied from
Chunk
def toList: List[O]
Converts this chunk to a list.
Inhertied from
Chunk
def toVector: Vector[O]
Converts this chunk to a vector.
Inhertied from
Chunk
def startsWith[O2 >: O](seq: Seq[O2]): Boolean
Check to see if this starts with the items in the given seq
should be the same as take(seq.size).toChunk == Chunk.seq(seq).
Inhertied from
Chunk
def zipWithIndex: Chunk[(O, Int)]
Zips the elements of the input chunk with its indices, and returns the new chunk.
Example
{{{
scala> Chunk("The", "quick", "brown", "fox").zipWithIndex.toList
res0: List[(String, Int)] = List((The,0), (quick,1), (brown,2), (fox,3))
}}}
Inhertied from
Chunk
def collect[O2](pf: PartialFunction[O, O2]): Chunk[O2]
More efficient version of filter(pf.isDefinedAt).map(pf).
Inhertied from
Chunk
override def toString: String
Definition Classes
Chunk -> Any
Inhertied from
Chunk
def toByteVector[B >: O](ev: B =:= Byte): ByteVector
Converts this chunk to a scodec-bits ByteVector.
Inhertied from
Chunk
final def isEmpty: Boolean
True if size is zero, false otherwise.
Inhertied from
Chunk
def toBitVector[B >: O](ev: B =:= Byte): BitVector
Converts this chunk to a scodec-bits BitVector.
Inhertied from
Chunk
def ++[O2 >: O](that: Chunk[O2]): Chunk[O2]
Returns a chunk which consists of the elements of this chunk and the elements of
the supplied chunk. This operation is amortized O(1).
Inhertied from
Chunk
def traverseFilter[F <: ([_$9] =>> Any), O2](f: O => F[Option[O2]])(F: Applicative[F]): F[Chunk[O2]]
Inhertied from
Chunk
def mapFilter[O2](f: O => Option[O2]): Chunk[O2]
Maps the supplied function over each element and returns a chunk of just the defined results.
Inhertied from
Chunk
def scanLeftCarry[O2](z: O2)(f: (O2, O) => O2): (Chunk[O2], O2)
Like scanLeft except the final element is emitted as a standalone value instead of as
the last element of the accumulated chunk.
Equivalent to val b = a.scanLeft(z)(f); val (c, carry) = b.splitAt(b.size - 1).
Inhertied from
Chunk
def last: Option[O]
Gets the last element of this chunk.
Inhertied from
Chunk
def toByteBuffer[B >: O](ev: B =:= Byte): ByteBuffer
Converts this chunk to a java.nio.ByteBuffer.
Inhertied from
Chunk
def indexWhere(p: O => Boolean): Option[Int]
Returns the index of the first element which passes the specified predicate (i.e., p(i) == true)
or None if no elements pass the predicate.
Inhertied from
Chunk
def reverseIterator: Iterator[O]
Creates an iterator that iterates the elements of this chunk in reverse order. The returned iterator is not thread safe.
Inhertied from
Chunk
override def hashCode: Int
Definition Classes
Chunk -> Any
Inhertied from
Chunk
def forall(p: O => Boolean): Boolean
Returns true if the predicate passes for all elements.
Inhertied from
Chunk
final def nonEmpty: Boolean
False if size is zero, true otherwise.
Inhertied from
Chunk
def toIArray[O2 >: O](evidence$2: ClassTag[O2]): IArray[O2]
Inhertied from
ChunkPlatform
def zipWith[O2, O3](that: Chunk[O2])(f: (O, O2) => O3): Chunk[O3]
Zips this chunk with the supplied chunk, passing each pair to f, resulting in
an output chunk.
Inhertied from
Chunk
override def equals(a: Any): Boolean
Definition Classes
Chunk -> Any
Inhertied from
Chunk
def takeRight(n: Int): Chunk[O]
Takes the right-most n elements of this chunk queue in a way that preserves chunk structure.
Inhertied from
Chunk