Buffer

abstract def array: IO[Exception, Array[A]]

abstract def asReadOnlyBuffer: IO[Nothing, Buffer[A]]

abstract def compact: IO[ReadOnlyBufferException, Unit]

abstract def duplicate: IO[Nothing, Buffer[A]]

abstract def get(i: Int): IO[IndexOutOfBoundsException, A]

abstract def get: IO[BufferUnderflowException, A]

abstract def getChunk(maxLength: Int = Int.MaxValue): IO[BufferUnderflowException, Chunk[A]]

abstract def order: ByteOrder

abstract def put(index: Int, element: A): IO[Exception, Unit]

abstract def put(element: A): IO[Exception, Unit]

abstract def putChunk(chunk: Chunk[A]): IO[Exception, Unit]

abstract def slice: IO[Nothing, Buffer[A]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def capacity: Int

final def clear: UIO[Unit]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fillFromChunk(chunk: Chunk[A]): IO[Nothing, Chunk[A]]

Writes as much of a chunk as possible to this buffer.

def finalize(): Unit

final def flip: UIO[Unit]

final def getClass(): Class[_]

final def hasArray: Boolean

final def hasRemaining: UIO[Boolean]

def hashCode(): Int

final def isDirect: Boolean

final def isInstanceOf[T0]: Boolean

final def isReadOnly: Boolean

final def limit(newLimit: Int): IO[Exception, Unit]

final def limit: UIO[Int]

final def mark: UIO[Unit]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def position(newPosition: Int): IO[Exception, Unit]

final def position: UIO[Int]

final def remaining: UIO[Int]

final def reset: IO[Exception, Unit]

final def rewind: UIO[Unit]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withArray[R, E, B](noArray: ZIO[R, E, B])(hasArray: (Array[A], Int) ⇒ ZIO[R, E, B]): ZIO[R, E, B]