StreamEncoder

abstract def encoder: Process1[A, BitVector]

The Process1 backing this StreamEncoder[A].

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++[A2 <: A](e: StreamEncoder[A2]): StreamEncoder[A2]

Run this StreamEncoder, followed by e.

def ->[B](y: B): (StreamEncoder[A], B)

final def ==(arg0: Any): Boolean

def as[B](implicit as: Transformer[A, B]): StreamEncoder[B]

final def asInstanceOf[T0]: T0

def chunk(bitsPerChunk: Long): StreamEncoder[A]

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

def clone(): AnyRef

final def contramap[A0](f0: (A0) ⇒ A): StreamEncoder[A0]

Transform the input type of this StreamEncoder.

final def contrapipe[A0](p: Process1[A0, A]): StreamEncoder[A0]

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

final def edit[A2](f: (Process1[A, BitVector]) ⇒ Process1[A2, BitVector]): StreamEncoder[A2]

Modify the Process1 backing this StreamEncoder.

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

Encode the input stream of A values using this StreamEncoder.

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

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

def ensuring(cond: (StreamEncoder[A]) ⇒ Boolean, msg: ⇒ Any): StreamEncoder[A]

def ensuring(cond: (StreamEncoder[A]) ⇒ Boolean): StreamEncoder[A]

def ensuring(cond: Boolean, msg: ⇒ Any): StreamEncoder[A]

def ensuring(cond: Boolean): StreamEncoder[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exmap[B](f: (A) ⇒ Attempt[B], g: (B) ⇒ Attempt[A]): StreamEncoder[B]

def exmapc[B](f: (A) ⇒ Attempt[B])(g: (B) ⇒ Attempt[A]): StreamEncoder[B]

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def many: StreamEncoder[A]

Encode values as long as there are more inputs.

def mapBits(f: (BitVector) ⇒ BitVector): StreamEncoder[A]

Transform the output BitVector values produced by this encoder.

def narrow[B](f: (A) ⇒ Attempt[B], g: (B) ⇒ A): StreamEncoder[B]

def narrowc[B](f: (A) ⇒ Attempt[B])(g: (B) ⇒ A): StreamEncoder[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pipeBits(f: Process1[BitVector, BitVector]): StreamEncoder[A]

Statefully transform the output BitVector values produced by this encoder.

val self: StreamEncoder[A]

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

def take(n: Int): StreamEncoder[A]

Encode at most n values.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def widen[B](f: (A) ⇒ B, g: (B) ⇒ Attempt[A]): StreamEncoder[B]

def widenOpt[B](f: (A) ⇒ B, g: (B) ⇒ Option[A]): StreamEncoder[B]

def widenOptc[B](f: (A) ⇒ B)(g: (B) ⇒ Option[A]): StreamEncoder[B]

def widenc[B](f: (A) ⇒ B)(g: (B) ⇒ Attempt[A]): StreamEncoder[B]

def xmap[B](f: (A) ⇒ B, g: (B) ⇒ A): StreamEncoder[B]

def xmapc[B](f: (A) ⇒ B)(g: (B) ⇒ A): StreamEncoder[B]

def →[B](y: B): (StreamEncoder[A], B)

def pxmap[B](f: (A) ⇒ B, g: (B) ⇒ Option[A]): StreamEncoder[B]