StreamGenCodec

abstract def decoder: Process[Cursor, O]

The Process backing this StreamDecoder.

abstract def encoder: Process1[I, BitVector]

The Process1 backing this StreamEncoder[A].

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[A2 >: O](d: ⇒ decode.StreamDecoder[A2]): decode.StreamDecoder[A2]

Run this StreamDecoder, then d, then concatenate the two streams.

def ++[A2 <: I](e: encode.StreamEncoder[A2]): encode.StreamEncoder[A2]

Run this StreamEncoder, followed by e.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def chunk(bitsPerChunk: Long): encode.StreamEncoder[I]

Convert this StreamEncoder to output bits in the given chunk size.

def clone(): AnyRef

final def collect[B](pf: PartialFunction[O, B]): decode.StreamDecoder[B]

Transform the output of this StreamDecoder using the partial function pf.

final def contramap[A0](f0: (A0) ⇒ I): encode.StreamEncoder[A0]

Transform the input type of this StreamEncoder.

final def contrapipe[A0](p: Process1[A0, I]): encode.StreamEncoder[A0]

Transform the input type of this StreamEncoder using the given transducer.

final def decode(bits: ⇒ BitVector): Process[Task, O]

Decoding a stream of A values from the given BitVector.

def decodeAllValid(bits: ⇒ BitVector): Vector[O]

Decode the given BitVector, returning a strict Vector of the results, and throwing an exception in the event of a decoding error.

final def decodeAsyncResource[R](acquire: Task[R])(read: (R) ⇒ BitVector, release: (R) ⇒ Task[Unit]): Process[Task, O]

Resource-safe version of decode.

final def decodeChannel(in: ⇒ ReadableByteChannel, chunkSizeInBytes: Int = 1024 * 1000 * 16, direct: Boolean = false): Process[Task, O]

Resource-safe version of decode for a ReadableByteChannel resource.

final def decodeInputStream(in: ⇒ InputStream, chunkSizeInBytes: Int = 1024 * 1000 * 16): Process[Task, O]

Resource-safe version of decode for an InputStream resource.

final def decodeMmap(in: ⇒ FileChannel, chunkSizeInBytes: Int = 1024 * 1000 * 16): Process[Task, O]

Resource-safe version of decode for a ReadableByteChannel resource.

final def decodeResource[R](acquire: ⇒ R)(read: (R) ⇒ BitVector, release: (R) ⇒ Unit): Process[Task, O]

Resource-safe version of decode.

def drop(n: Int): decode.StreamDecoder[O]

Ignore the first n decoded values.

def dropWhile(f: (O) ⇒ Boolean): decode.StreamDecoder[O]

Ignore decoded values as long as the predicate tests true.

final def edit[B](f: (Process[Cursor, O]) ⇒ Process[Cursor, B]): decode.StreamDecoder[B]

Modify the Process[Cursor,A] backing this StreamDecoder.

final def edit[A2](f: (Process1[I, BitVector]) ⇒ Process1[A2, BitVector]): encode.StreamEncoder[A2]

Modify the Process1 backing this StreamEncoder.

def editDecoder[O2](f: (StreamDecoder[O]) ⇒ StreamDecoder[O2]): StreamGenCodec[I, O2]

def editEncoder[I2](f: (StreamEncoder[I]) ⇒ StreamEncoder[I2]): StreamGenCodec[I2, O]

final def encode[F[_]](in: Process[F, I]): Process[F, BitVector]

Encode the input stream of A values using this StreamEncoder.

def encodeAllValid(in: Seq[I]): BitVector

Encode the given sequence of A values to a BitVector, raising an exception in the event of an encoding error.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: (O) ⇒ Boolean): decode.StreamDecoder[O]

Skip any decoded values for which the predicate tests false.

def finalize(): Unit

def firstAfter(f: (O) ⇒ Boolean): decode.StreamDecoder[O]

Equivalent to dropWhile(f).take(1) - returns a stream of (at most) one element, consisting of the first output for which f tests false.

final def flatMap[B](f: (O) ⇒ decode.StreamDecoder[B]): decode.StreamDecoder[B]

Monadic bind for this StreamDecoder.

final def flatMapP[B](f: (O) ⇒ Process[Cursor, B]): decode.StreamDecoder[B]

Like flatMap, but takes a function that produces a Process[Cursor,B].

def fuse[II <: I, OO >: O](implicit ev: =:=[OO, II]): StreamCodec[OO]

Promote to a StreamCodec[O] given evidence that I and O are equal.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isolate(numberOfBits: Long): decode.StreamDecoder[O]

Alias for decode.isolate(numberOfBits)(this).

def isolateBytes(numberOfBytes: Long): decode.StreamDecoder[O]

Alias for decode.isolateBytes(numberOfBytes)(this).

def many: StreamGenCodec[I, O]

Run this StreamDecoder zero or more times until the input is exhausted.

def many1: decode.StreamDecoder[O]

Run this StreamDecoder one or more times until the input is exhausted.

final def map[B](f: (O) ⇒ B): decode.StreamDecoder[B]

Transform the output of this StreamDecoder using the function f.

def mapBits(f: (BitVector) ⇒ BitVector): encode.StreamEncoder[I]

Transform the output BitVector values produced by this encoder.

final def mapEither[B](f: (O) ⇒ \/[Err, B]): decode.StreamDecoder[B]

Transform the output of this StreamDecoder, converting left values to decoding failures.

final def ne(arg0: AnyRef): Boolean

def nonEmpty(errIfEmpty: Err): decode.StreamDecoder[O]

Raises a decoding error if the given decoder emits no results, otherwise runs p as normal.

final def notify(): Unit

final def notifyAll(): Unit

final def onComplete[A2 >: O](d: ⇒ decode.StreamDecoder[A2]): decode.StreamDecoder[A2]

Run this StreamDecoder, then d, then concatenate the two streams, even if this halts with an error.

final def or[A2 >: O](d: decode.StreamDecoder[A2]): decode.StreamDecoder[A2]

Alias for scodec.stream.decode.or(this,d).

def peek: decode.StreamDecoder[O]

Alias for scodec.stream.decode.peek(this).

final def pipe[B](p: Process1[O, B]): decode.StreamDecoder[B]

Transform the output of this StreamDecoder using the given single-input stream transducer.

def pipeBits(f: Process1[BitVector, BitVector]): encode.StreamEncoder[I]

Statefully transform the output BitVector values produced by this encoder.

def sepBy[B](implicit arg0: Decoder[B]): decode.StreamDecoder[O]

Alternate between decoding A values using this StreamDecoder, and decoding B values which are ignored.

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

def take(n: Int): StreamGenCodec[I, O]

Decode at most n values using this StreamDecoder.

def takeWhile(f: (O) ⇒ Boolean): decode.StreamDecoder[O]

Decode values as long as the predicate tests true.

final def tee[B, C](d: decode.StreamDecoder[B])(t: Tee[O, B, C]): decode.StreamDecoder[C]

Combine the output of this StreamDecoder with another streaming decoder, using the given binary stream transducer.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(f: (O) ⇒ Boolean): decode.StreamDecoder[O]

Skip any decoded values for which the predicate tests false.

final def |[A2 >: O](d: decode.StreamDecoder[A2]): decode.StreamDecoder[A2]

Operator alias for this.or(d).

final def |>[B](p: Process1[O, B]): decode.StreamDecoder[B]

Alias for this pipe p.