Package: go.pact.im/x/extraio

package extraio Import Path go.pact.im/x/extraio (on go.dev) Dependency Relation imports 4 packages, and imported by 0 packages Involved Source Files byte.go count.go discard.go #d extraio.go Package extraio implements extra I/O utilities. func.go hardlimit.go hash.go pad.go tail.go unpad.go Package-Level Type Names (total 9, all are exported) /* sort exporteds by: alphabet | popularity */ type ByteReader byte (basic type) ByteReader is an io.Reader that reads the same byte indefinitely. Methods (only one, which is exported) ( ByteReader) Read(p []byte) (n int, err error) Read implements the io.Reader interface. It fills p with the b byte and returns len(p). Implements (at least one exported) ByteReader : io.Reader type CountReader (struct) CountReader counts bytes read from the underlying io.Reader. It is implicitly limited to at most math.MaxUint64 bytes and returns ErrCounterOverflow error if the limit is exceeded. In practice, that would require counting thousands of petabytes to reach this limitation. Fields (total 2, neither is exported) /* 2 unexporteds ... *//* 2 unexporteds: */ count uint64 // mutable reader io.Reader Methods (total 2, both are exported) (*CountReader) Count() uint64 Count returns the count of bytes read. (*CountReader) Read(p []byte) (int, error) Read implements the io.Reader interface. It reads from the underlying io.Reader and increments read bytes counter. Implements (at least one exported) *CountReader : io.Reader As Outputs Of (at least one exported) func NewCountReader(r io.Reader) *CountReader type DiscardReader (struct) DiscardReader is an io.Reader that discard all read bytes from the underlying reader. Note that its Read method returns zero byte count. Some io.Reader client implementations return io.ErrNoProgress error when many calls to Read have failed to return any data or error. Fields (only one, which is unexported) /* one unexported ... *//* one unexported: */ reader io.Reader Methods (only one, which is exported) (*DiscardReader) Read(p []byte) (int, error) Read implements the io.Reader interface. It reads from the underlying io.Reader but always returns zero byte count. Implements (at least one exported) *DiscardReader : io.Reader As Outputs Of (at least one exported) func NewDiscardReader(r io.Reader) *DiscardReader type HardLimitedReader (struct) HardLimitedReader reads at most n bytes from the underlying reader and returns ErrExceededReadLimit if io.EOF is not reached once the limit is exceeded. Fields (total 3, none are exported) /* 3 unexporteds ... *//* 3 unexporteds: */ limit uint64 readCount uint64 // mutable reader io.Reader Methods (total 2, both are exported) (*HardLimitedReader) Read(p []byte) (int, error) Read implements the io.Reader interface. If the limit has been reached, it returns ErrExceededReadLimit error. Otherwise it reads from the underlying io.Reader. (*HardLimitedReader) Reset() Reset resets the reader’s state. Implements (at least one exported) *HardLimitedReader : io.Reader As Outputs Of (at least one exported) func HardLimitReader(r io.Reader, n uint64) *HardLimitedReader type HashReader (struct) HashReader wraps hash.Hash as an io.Reader. It assumes that the underlying hash state does not change after the first Read call. Fields (total 3, none are exported) /* 3 unexporteds ... *//* 3 unexporteds: */ buf []byte // mutable h hash.Hash off int // mutable Methods (total 3, all are exported) (*HashReader) Hash() hash.Hash Hash returns the underlying hash function. (*HashReader) Read(p []byte) (int, error) Read implements the io.Reader interface. It computes the hash on the first call and advances through the hash buffer on subsequent calls to Read. (*HashReader) Reset() Reset resets the reader’s state. It does not reset the state of the underlying hash function. Implements (at least one exported) *HashReader : io.Reader As Outputs Of (at least one exported) func NewHashReader(h hash.Hash) *HashReader type PadReader (struct) PadReader is an io.Reader that always adds non-zero padding on EOF. The the value of the padding bytes is equal to the length of the padding. Fields (total 5, none are exported) /* 5 unexporteds ... *//* 5 unexporteds: */ blockSize uint8 fillByte byte // mutable incomplete int // mutable padding uint8 // mutable reader io.Reader Methods (total 3, in which 2 are exported) (*PadReader) Read(p []byte) (int, error) Read implements the io.Reader interface. It reads from the underlying io.Reader until EOF and then writes padding into the read buffer. (*PadReader) Reset() Reset resets the reader’s state. /* one unexported ... *//* one unexported: */ (*PadReader) pad(p []byte) (int, error) pad writes padding to p. Implements (at least one exported) *PadReader : io.Reader As Outputs Of (at least one exported) func NewPadReader(r io.Reader, blockSize uint8) *PadReader type ReaderFunc (func) ReaderFunc is an adapter to allow the use of ordinary function as io.Reader. If f is a function with appropriate signature, ReaderFunc(f) is an io.Reader that calls f. Methods (only one, which is exported) ( ReaderFunc) Read(p []byte) (n int, err error) Read implements the io.Reader interface. It calls f(p). Implements (at least one exported) ReaderFunc : io.Reader type TailReader (struct) TailReader buffers the last n bytes read from the underlying io.Reader. That is, its Read method does not return last n bytes read. Use Tail method to get the underlying buffer on EOF. Note that its Read method may return zero byte count with a nil error if read bytes fit into the underlying buffer. Some io.Reader client implementations return io.ErrNoProgress error when many calls to Read have failed to return any data or error. Fields (total 3, none are exported) /* 3 unexporteds ... *//* 3 unexporteds: */ buf []byte // mutable cur int // mutable reader io.Reader Methods (total 5, in which 4 are exported) (*TailReader) Length() int Length returns the length of the underlying buffer. It is faster than calling len(r.Tail()) since the underlying buffer may not be contiguous and Tail has to linearize it to return a contiguous slice of bytes. (*TailReader) Read(p []byte) (int, error) Read implements the io.Reader interface. It reads from the underlying io.Reader but keeps the last n read bytes in the internal ring buffer. (*TailReader) Reset() Reset resets the reader’s state. (*TailReader) Tail() []byte Tail returns the buffer with last read bytes. The underlying buffer may not be contiguous and Tail linearizes the contents before returning a contiguous byte slice. /* one unexported ... *//* one unexported: */ (*TailReader) linearize() linearize makes the underlying ring buffer contiguous. Implements (at least one exported) *TailReader : io.Reader As Outputs Of (at least one exported) func NewTailReader(r io.Reader, n uint) *TailReader type UnpadReader (struct) UnpadReader is an io.Reader that unpads padding from PadReader. It validates the padding on EOF and returns an error if it is invalid. Fields (total 4, none are exported) /* 4 unexporteds ... *//* 4 unexporteds: */ blockSize uint8 incomplete int // mutable lastBlock []byte // mutable reader TailReader Methods (total 3, in which 2 are exported) (*UnpadReader) Read(p []byte) (int, error) Read implements the io.Reader interface. It reads from the underlying io.Reader until EOF and then validates and removes padding from the last block. (*UnpadReader) Reset() Reset resets the reader’s state. /* one unexported ... *//* one unexported: */ (*UnpadReader) unpad(p []byte) (int, error) unpad writes remaining payload to p. Implements (at least one exported) *UnpadReader : io.Reader As Outputs Of (at least one exported) func NewUnpadReader(r io.Reader, blockSize uint8) *UnpadReader Package-Level Functions (total 13, in which 8 are exported) func HardLimitReader(r io.Reader, n uint64) *HardLimitedReader HardLimitReader returns a Reader that reads from r but stops with an error after n bytes. func NewCountReader(r io.Reader) *CountReader NewCountReader returns a new reader that counts bytes read from r. func NewDiscardReader(r io.Reader) *DiscardReader NewDiscardReader returns a new reader that discard all reads from r. func NewHashReader(h hash.Hash) *HashReader NewHashReader returns a new reader that reads from the given hash function. func NewPadReader(r io.Reader, blockSize uint8) *PadReader NewPadReader returns a new reader that pads r with the given block size. If blockSize is zero, PadReader is a no-op, i.e. it does not attempt to add padding to the underlying reader. func NewStrippedHashReader(h hash.Hash, n int64) io.Reader NewStrippedHashReader returns a new io.Reader that reads at most n bytes of the given hash function. func NewTailReader(r io.Reader, n uint) *TailReader NewTailReader returns a new reader that buffers last n bytes read from r. func NewUnpadReader(r io.Reader, blockSize uint8) *UnpadReader NewUnpadReader returns a new reader that unpads r using the given block size. If blockSize is zero, UnpadReader is a no-op, i.e. it does not attempt to remove padding from the underlying reader. /* 5 unexporteds ... *//* 5 unexporteds: */ func min(a, b int) int min returns the minimum of the two integers. func reverse(s []byte) reverse performs in-place reversal of the slice. func rotate(s []byte, n int) rotate performs in-place left rotation of the slice by n positions from the start for positive n. If n is negative, the slice is right rotated by the absolute value of n. Examples: rotate([]byte("lohel"), 2) => []byte("hello") rotate([]byte("45123"), 2) => []byte("12345") rotate([]byte("34512"), -2) => []byte("12345") func swap(dst, src []byte) int swap swaps elements between dst and src slices. It returns the number of swapped elements, that is, min(len(dst), len(src)). func unpadPayload(buf []byte, fillByte byte) ([]byte, bool) unpadPayload validates that buf is padded with fillByte bytes and returns the unpadded payload. Package-Level Variables (total 2, both are exported) var ErrCounterOverflow error ErrCounterOverflow is an error that CountReader returns when the counter overflows 64-bit unsigned integer. var ErrExceededReadLimit error ErrExceededReadLimit is an error that HardLimitedReader returns when it exceeds read limit.