IsByte

package

v0.0.0-...-5012a73 Latest Latest Go to latest Published: Jun 20, 2019 License: MIT Imports: 3 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/golangsam/anytype

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
func BufferDaisy(inp <-chan bytes.Buffer, tube BufferTube) (out <-chan bytes.Buffer)
func BufferDaisyChain(inp <-chan bytes.Buffer, tubes ...BufferTube) (out <-chan bytes.Buffer)
func ByteDaisy(inp <-chan byte, tube ByteTube) (out <-chan byte)
func ByteDaisyChain(inp <-chan byte, tubes ...ByteTube) (out <-chan byte)
func ByteReaderDaisy(inp <-chan io.ByteReader, tube ByteReaderTube) (out <-chan io.ByteReader)
func ByteReaderDaisyChain(inp <-chan io.ByteReader, tubes ...ByteReaderTube) (out <-chan io.ByteReader)
func ByteScannerDaisy(inp <-chan io.ByteScanner, tube ByteScannerTube) (out <-chan io.ByteScanner)
func ByteScannerDaisyChain(inp <-chan io.ByteScanner, tubes ...ByteScannerTube) (out <-chan io.ByteScanner)
func ByteWriterDaisy(inp <-chan io.ByteWriter, tube ByteWriterTube) (out <-chan io.ByteWriter)
func ByteWriterDaisyChain(inp <-chan io.ByteWriter, tubes ...ByteWriterTube) (out <-chan io.ByteWriter)
func Chan(inp ...[]byte) chan []byte
func ChanBuffer(inp ...bytes.Buffer) chan bytes.Buffer
func ChanBufferFuncErr(act func() (bytes.Buffer, error)) <-chan bytes.Buffer
func ChanBufferFuncNok(act func() (bytes.Buffer, bool)) <-chan bytes.Buffer
func ChanBufferSlice(inp ...[]bytes.Buffer) chan bytes.Buffer
func ChanByte(inp ...byte) chan byte
func ChanByteFuncErr(act func() (byte, error)) <-chan byte
func ChanByteFuncNok(act func() (byte, bool)) <-chan byte
func ChanByteReader(inp ...io.ByteReader) chan io.ByteReader
func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) <-chan io.ByteReader
func ChanByteReaderFuncNok(act func() (io.ByteReader, bool)) <-chan io.ByteReader
func ChanByteReaderSlice(inp ...[]io.ByteReader) chan io.ByteReader
func ChanByteScanner(inp ...io.ByteScanner) chan io.ByteScanner
func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) <-chan io.ByteScanner
func ChanByteScannerFuncNok(act func() (io.ByteScanner, bool)) <-chan io.ByteScanner
func ChanByteScannerSlice(inp ...[]io.ByteScanner) chan io.ByteScanner
func ChanByteSlice(inp ...[]byte) chan byte
func ChanByteWriter(inp ...io.ByteWriter) chan io.ByteWriter
func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) <-chan io.ByteWriter
func ChanByteWriterFuncNok(act func() (io.ByteWriter, bool)) <-chan io.ByteWriter
func ChanByteWriterSlice(inp ...[]io.ByteWriter) chan io.ByteWriter
func ChanFuncErr(act func() ([]byte, error)) <-chan []byte
func ChanFuncNok(act func() ([]byte, bool)) <-chan []byte
func ChanReader(inp ...bytes.Reader) chan bytes.Reader
func ChanReaderFuncErr(act func() (bytes.Reader, error)) <-chan bytes.Reader
func ChanReaderFuncNok(act func() (bytes.Reader, bool)) <-chan bytes.Reader
func ChanReaderSlice(inp ...[]bytes.Reader) chan bytes.Reader
func ChanSlice(inp ...[][]byte) chan []byte
func Daisy(inp <-chan []byte, tube Tube) (out <-chan []byte)
func DaisyChain(inp <-chan []byte, tubes ...Tube) (out <-chan []byte)
func Done(inp <-chan []byte) chan struct{}
func DoneBuffer(inp <-chan bytes.Buffer) chan struct{}
func DoneBufferFunc(inp <-chan bytes.Buffer, act func(a bytes.Buffer)) chan struct{}
func DoneBufferSlice(inp <-chan bytes.Buffer) chan []bytes.Buffer
func DoneByte(inp <-chan byte) chan struct{}
func DoneByteFunc(inp <-chan byte, act func(a byte)) chan struct{}
func DoneByteReader(inp <-chan io.ByteReader) chan struct{}
func DoneByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader)) chan struct{}
func DoneByteReaderSlice(inp <-chan io.ByteReader) chan []io.ByteReader
func DoneByteScanner(inp <-chan io.ByteScanner) chan struct{}
func DoneByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner)) chan struct{}
func DoneByteScannerSlice(inp <-chan io.ByteScanner) chan []io.ByteScanner
func DoneByteSlice(inp <-chan byte) chan []byte
func DoneByteWriter(inp <-chan io.ByteWriter) chan struct{}
func DoneByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter)) chan struct{}
func DoneByteWriterSlice(inp <-chan io.ByteWriter) chan []io.ByteWriter
func DoneFunc(inp <-chan []byte, act func(a []byte)) chan struct{}
func DoneReader(inp <-chan bytes.Reader) chan struct{}
func DoneReaderFunc(inp <-chan bytes.Reader, act func(a bytes.Reader)) chan struct{}
func DoneReaderSlice(inp <-chan bytes.Reader) chan []bytes.Reader
func DoneSlice(inp <-chan []byte) chan [][]byte
func Join(out chan<- []byte, inp ...[]byte) chan struct{}
func JoinBuffer(out chan<- bytes.Buffer, inp ...bytes.Buffer) chan struct{}
func JoinBufferChan(out chan<- bytes.Buffer, inp <-chan bytes.Buffer) chan struct{}
func JoinBufferSlice(out chan<- bytes.Buffer, inp ...[]bytes.Buffer) chan struct{}
func JoinByte(out chan<- byte, inp ...byte) chan struct{}
func JoinByteChan(out chan<- byte, inp <-chan byte) chan struct{}
func JoinByteReader(out chan<- io.ByteReader, inp ...io.ByteReader) chan struct{}
func JoinByteReaderChan(out chan<- io.ByteReader, inp <-chan io.ByteReader) chan struct{}
func JoinByteReaderSlice(out chan<- io.ByteReader, inp ...[]io.ByteReader) chan struct{}
func JoinByteScanner(out chan<- io.ByteScanner, inp ...io.ByteScanner) chan struct{}
func JoinByteScannerChan(out chan<- io.ByteScanner, inp <-chan io.ByteScanner) chan struct{}
func JoinByteScannerSlice(out chan<- io.ByteScanner, inp ...[]io.ByteScanner) chan struct{}
func JoinByteSlice(out chan<- byte, inp ...[]byte) chan struct{}
func JoinByteWriter(out chan<- io.ByteWriter, inp ...io.ByteWriter) chan struct{}
func JoinByteWriterChan(out chan<- io.ByteWriter, inp <-chan io.ByteWriter) chan struct{}
func JoinByteWriterSlice(out chan<- io.ByteWriter, inp ...[]io.ByteWriter) chan struct{}
func JoinChan(out chan<- []byte, inp <-chan []byte) chan struct{}
func JoinReader(out chan<- bytes.Reader, inp ...bytes.Reader) chan struct{}
func JoinReaderChan(out chan<- bytes.Reader, inp <-chan bytes.Reader) chan struct{}
func JoinReaderSlice(out chan<- bytes.Reader, inp ...[]bytes.Reader) chan struct{}
func JoinSlice(out chan<- []byte, inp ...[][]byte) chan struct{}
func MakeBufferChan() chan bytes.Buffer
func MakeByteChan() chan byte
func MakeByteReaderChan() chan io.ByteReader
func MakeByteScannerChan() chan io.ByteScanner
func MakeByteWriterChan() chan io.ByteWriter
func MakeChan() chan []byte
func MakeReaderChan() chan bytes.Reader
func PipeBuffer(inp <-chan []byte, cap int) chan []byte
func PipeBufferBuffer(inp <-chan bytes.Buffer, cap int) chan bytes.Buffer
func PipeBufferFork(inp <-chan bytes.Buffer) (chan bytes.Buffer, chan bytes.Buffer)
func PipeBufferFunc(inp <-chan bytes.Buffer, act func(a bytes.Buffer) bytes.Buffer) chan bytes.Buffer
func PipeByteBuffer(inp <-chan byte, cap int) chan byte
func PipeByteFork(inp <-chan byte) (chan byte, chan byte)
func PipeByteFunc(inp <-chan byte, act func(a byte) byte) chan byte
func PipeByteReaderBuffer(inp <-chan io.ByteReader, cap int) chan io.ByteReader
func PipeByteReaderFork(inp <-chan io.ByteReader) (chan io.ByteReader, chan io.ByteReader)
func PipeByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader) io.ByteReader) chan io.ByteReader
func PipeByteScannerBuffer(inp <-chan io.ByteScanner, cap int) chan io.ByteScanner
func PipeByteScannerFork(inp <-chan io.ByteScanner) (chan io.ByteScanner, chan io.ByteScanner)
func PipeByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner) io.ByteScanner) chan io.ByteScanner
func PipeByteWriterBuffer(inp <-chan io.ByteWriter, cap int) chan io.ByteWriter
func PipeByteWriterFork(inp <-chan io.ByteWriter) (chan io.ByteWriter, chan io.ByteWriter)
func PipeByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter) io.ByteWriter) chan io.ByteWriter
func PipeFork(inp <-chan []byte) (chan []byte, chan []byte)
func PipeFunc(inp <-chan []byte, act func(a []byte) []byte) chan []byte
func PipeReaderBuffer(inp <-chan bytes.Reader, cap int) chan bytes.Reader
func PipeReaderFork(inp <-chan bytes.Reader) (chan bytes.Reader, chan bytes.Reader)
func PipeReaderFunc(inp <-chan bytes.Reader, act func(a bytes.Reader) bytes.Reader) chan bytes.Reader
func ReaderDaisy(inp <-chan bytes.Reader, tube ReaderTube) (out <-chan bytes.Reader)
func ReaderDaisyChain(inp <-chan bytes.Reader, tubes ...ReaderTube) (out <-chan bytes.Reader)
func SendProxy(out chan<- []byte) chan<- []byte
func SendProxyBuffer(out chan<- bytes.Buffer) chan<- bytes.Buffer
func SendProxyByte(out chan<- byte) chan<- byte
func SendProxyByteReader(out chan<- io.ByteReader) chan<- io.ByteReader
func SendProxyByteScanner(out chan<- io.ByteScanner) chan<- io.ByteScanner
func SendProxyByteWriter(out chan<- io.ByteWriter) chan<- io.ByteWriter
func SendProxyReader(out chan<- bytes.Reader) chan<- bytes.Reader
type BufferTube
type ByteReaderTube
type ByteScannerTube
type ByteTube
type ByteWriterTube
type ReaderTube
type Tube

Constants ¶

View Source

const BufferCAP = 10

BufferCAP is the capacity of the buffered proxy channel

View Source

const BufferQUE = 16

BufferQUE is the allocated size of the circular queue

View Source

const ByteCAP = 10

ByteCAP is the capacity of the buffered proxy channel

View Source

const ByteQUE = 16

ByteQUE is the allocated size of the circular queue

View Source

const ByteReaderCAP = 10

ByteReaderCAP is the capacity of the buffered proxy channel

View Source

const ByteReaderQUE = 16

ByteReaderQUE is the allocated size of the circular queue

View Source

const ByteScannerCAP = 10

ByteScannerCAP is the capacity of the buffered proxy channel

View Source

const ByteScannerQUE = 16

ByteScannerQUE is the allocated size of the circular queue

View Source

const ByteWriterCAP = 10

ByteWriterCAP is the capacity of the buffered proxy channel

View Source

const ByteWriterQUE = 16

ByteWriterQUE is the allocated size of the circular queue

View Source

const CAP = 10

CAP is the capacity of the buffered proxy channel

View Source

const QUE = 16

QUE is the allocated size of the circular queue

View Source

const ReaderCAP = 10

ReaderCAP is the capacity of the buffered proxy channel

View Source

const ReaderQUE = 16

ReaderQUE is the allocated size of the circular queue

Variables ¶

This section is empty.

Functions ¶

func BufferDaisy ¶

func BufferDaisy(inp <-chan bytes.Buffer, tube BufferTube) (out <-chan bytes.Buffer)

BufferDaisy returns a channel to receive all inp after having passed thru tube.

func BufferDaisyChain ¶

func BufferDaisyChain(inp <-chan bytes.Buffer, tubes ...BufferTube) (out <-chan bytes.Buffer)

BufferDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ByteDaisy ¶

func ByteDaisy(inp <-chan byte, tube ByteTube) (out <-chan byte)

ByteDaisy returns a channel to receive all inp after having passed thru tube.

func ByteDaisyChain ¶

func ByteDaisyChain(inp <-chan byte, tubes ...ByteTube) (out <-chan byte)

ByteDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ByteReaderDaisy ¶

func ByteReaderDaisy(inp <-chan io.ByteReader, tube ByteReaderTube) (out <-chan io.ByteReader)

ByteReaderDaisy returns a channel to receive all inp after having passed thru tube.

func ByteReaderDaisyChain ¶

func ByteReaderDaisyChain(inp <-chan io.ByteReader, tubes ...ByteReaderTube) (out <-chan io.ByteReader)

ByteReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ByteScannerDaisy ¶

func ByteScannerDaisy(inp <-chan io.ByteScanner, tube ByteScannerTube) (out <-chan io.ByteScanner)

ByteScannerDaisy returns a channel to receive all inp after having passed thru tube.

func ByteScannerDaisyChain ¶

func ByteScannerDaisyChain(inp <-chan io.ByteScanner, tubes ...ByteScannerTube) (out <-chan io.ByteScanner)

ByteScannerDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func ByteWriterDaisy ¶

func ByteWriterDaisy(inp <-chan io.ByteWriter, tube ByteWriterTube) (out <-chan io.ByteWriter)

ByteWriterDaisy returns a channel to receive all inp after having passed thru tube.

func ByteWriterDaisyChain ¶

func ByteWriterDaisyChain(inp <-chan io.ByteWriter, tubes ...ByteWriterTube) (out <-chan io.ByteWriter)

ByteWriterDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func Chan ¶

func Chan(inp ...[]byte) chan []byte

Chan returns a channel to receive all inputs before close.

func ChanBuffer ¶

func ChanBuffer(inp ...bytes.Buffer) chan bytes.Buffer

ChanBuffer returns a channel to receive all inputs before close.

func ChanBufferFuncErr ¶

func ChanBufferFuncErr(act func() (bytes.Buffer, error)) <-chan bytes.Buffer

ChanBufferFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanBufferFuncNok ¶

func ChanBufferFuncNok(act func() (bytes.Buffer, bool)) <-chan bytes.Buffer

ChanBufferFuncNok returns a channel to receive all results of act until nok before close.

func ChanBufferSlice ¶

func ChanBufferSlice(inp ...[]bytes.Buffer) chan bytes.Buffer

ChanBufferSlice returns a channel to receive all inputs before close.

func ChanByte ¶

func ChanByte(inp ...byte) chan byte

ChanByte returns a channel to receive all inputs before close.

func ChanByteFuncErr ¶

func ChanByteFuncErr(act func() (byte, error)) <-chan byte

ChanByteFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteFuncNok ¶

func ChanByteFuncNok(act func() (byte, bool)) <-chan byte

ChanByteFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteReader ¶

func ChanByteReader(inp ...io.ByteReader) chan io.ByteReader

ChanByteReader returns a channel to receive all inputs before close.

func ChanByteReaderFuncErr ¶

func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) <-chan io.ByteReader

ChanByteReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteReaderFuncNok ¶

func ChanByteReaderFuncNok(act func() (io.ByteReader, bool)) <-chan io.ByteReader

ChanByteReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteReaderSlice ¶

func ChanByteReaderSlice(inp ...[]io.ByteReader) chan io.ByteReader

ChanByteReaderSlice returns a channel to receive all inputs before close.

func ChanByteScanner ¶

func ChanByteScanner(inp ...io.ByteScanner) chan io.ByteScanner

ChanByteScanner returns a channel to receive all inputs before close.

func ChanByteScannerFuncErr ¶

func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) <-chan io.ByteScanner

ChanByteScannerFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteScannerFuncNok ¶

func ChanByteScannerFuncNok(act func() (io.ByteScanner, bool)) <-chan io.ByteScanner

ChanByteScannerFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteScannerSlice ¶

func ChanByteScannerSlice(inp ...[]io.ByteScanner) chan io.ByteScanner

ChanByteScannerSlice returns a channel to receive all inputs before close.

func ChanByteSlice ¶

func ChanByteSlice(inp ...[]byte) chan byte

ChanByteSlice returns a channel to receive all inputs before close.

func ChanByteWriter ¶

func ChanByteWriter(inp ...io.ByteWriter) chan io.ByteWriter

ChanByteWriter returns a channel to receive all inputs before close.

func ChanByteWriterFuncErr ¶

func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) <-chan io.ByteWriter

ChanByteWriterFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanByteWriterFuncNok ¶

func ChanByteWriterFuncNok(act func() (io.ByteWriter, bool)) <-chan io.ByteWriter

ChanByteWriterFuncNok returns a channel to receive all results of act until nok before close.

func ChanByteWriterSlice ¶

func ChanByteWriterSlice(inp ...[]io.ByteWriter) chan io.ByteWriter

ChanByteWriterSlice returns a channel to receive all inputs before close.

func ChanFuncErr ¶

func ChanFuncErr(act func() ([]byte, error)) <-chan []byte

ChanFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanFuncNok ¶

func ChanFuncNok(act func() ([]byte, bool)) <-chan []byte

ChanFuncNok returns a channel to receive all results of act until nok before close.

func ChanReader ¶

func ChanReader(inp ...bytes.Reader) chan bytes.Reader

ChanReader returns a channel to receive all inputs before close.

func ChanReaderFuncErr ¶

func ChanReaderFuncErr(act func() (bytes.Reader, error)) <-chan bytes.Reader

ChanReaderFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanReaderFuncNok ¶

func ChanReaderFuncNok(act func() (bytes.Reader, bool)) <-chan bytes.Reader

ChanReaderFuncNok returns a channel to receive all results of act until nok before close.

func ChanReaderSlice ¶

func ChanReaderSlice(inp ...[]bytes.Reader) chan bytes.Reader

ChanReaderSlice returns a channel to receive all inputs before close.

func ChanSlice ¶

func ChanSlice(inp ...[][]byte) chan []byte

ChanSlice returns a channel to receive all inputs before close.

func Daisy ¶

func Daisy(inp <-chan []byte, tube Tube) (out <-chan []byte)

Daisy returns a channel to receive all inp after having passed thru tube.

func DaisyChain ¶

func DaisyChain(inp <-chan []byte, tubes ...Tube) (out <-chan []byte)

DaisyChain returns a channel to receive all inp after having passed thru all tubes.

func Done ¶

func Done(inp <-chan []byte) chan struct{}

Done returns a channel to receive one signal before close after inp has been drained.

func DoneBuffer ¶

func DoneBuffer(inp <-chan bytes.Buffer) chan struct{}

DoneBuffer returns a channel to receive one signal before close after inp has been drained.

func DoneBufferFunc ¶

func DoneBufferFunc(inp <-chan bytes.Buffer, act func(a bytes.Buffer)) chan struct{}

DoneBufferFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneBufferSlice ¶

func DoneBufferSlice(inp <-chan bytes.Buffer) chan []bytes.Buffer

DoneBufferSlice returns a channel which will receive a slice of all the Buffers received on inp channel before close. Unlike DoneBuffer, a full slice is sent once, not just an event.

func DoneByte ¶

func DoneByte(inp <-chan byte) chan struct{}

DoneByte returns a channel to receive one signal before close after inp has been drained.

func DoneByteFunc ¶

func DoneByteFunc(inp <-chan byte, act func(a byte)) chan struct{}

DoneByteFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteReader ¶

func DoneByteReader(inp <-chan io.ByteReader) chan struct{}

DoneByteReader returns a channel to receive one signal before close after inp has been drained.

func DoneByteReaderFunc ¶

func DoneByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader)) chan struct{}

DoneByteReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteReaderSlice ¶

func DoneByteReaderSlice(inp <-chan io.ByteReader) chan []io.ByteReader

DoneByteReaderSlice returns a channel which will receive a slice of all the ByteReaders received on inp channel before close. Unlike DoneByteReader, a full slice is sent once, not just an event.

func DoneByteScanner ¶

func DoneByteScanner(inp <-chan io.ByteScanner) chan struct{}

DoneByteScanner returns a channel to receive one signal before close after inp has been drained.

func DoneByteScannerFunc ¶

func DoneByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner)) chan struct{}

DoneByteScannerFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteScannerSlice ¶

func DoneByteScannerSlice(inp <-chan io.ByteScanner) chan []io.ByteScanner

DoneByteScannerSlice returns a channel which will receive a slice of all the ByteScanners received on inp channel before close. Unlike DoneByteScanner, a full slice is sent once, not just an event.

func DoneByteSlice ¶

func DoneByteSlice(inp <-chan byte) chan []byte

DoneByteSlice returns a channel which will receive a slice of all the Bytes received on inp channel before close. Unlike DoneByte, a full slice is sent once, not just an event.

func DoneByteWriter ¶

func DoneByteWriter(inp <-chan io.ByteWriter) chan struct{}

DoneByteWriter returns a channel to receive one signal before close after inp has been drained.

func DoneByteWriterFunc ¶

func DoneByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter)) chan struct{}

DoneByteWriterFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneByteWriterSlice ¶

func DoneByteWriterSlice(inp <-chan io.ByteWriter) chan []io.ByteWriter

DoneByteWriterSlice returns a channel which will receive a slice of all the ByteWriters received on inp channel before close. Unlike DoneByteWriter, a full slice is sent once, not just an event.

func DoneFunc ¶

func DoneFunc(inp <-chan []byte, act func(a []byte)) chan struct{}

DoneFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReader ¶

func DoneReader(inp <-chan bytes.Reader) chan struct{}

DoneReader returns a channel to receive one signal before close after inp has been drained.

func DoneReaderFunc ¶

func DoneReaderFunc(inp <-chan bytes.Reader, act func(a bytes.Reader)) chan struct{}

DoneReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneReaderSlice ¶

func DoneReaderSlice(inp <-chan bytes.Reader) chan []bytes.Reader

DoneReaderSlice returns a channel which will receive a slice of all the Readers received on inp channel before close. Unlike DoneReader, a full slice is sent once, not just an event.

func DoneSlice ¶

func DoneSlice(inp <-chan []byte) chan [][]byte

DoneSlice returns a channel which will receive a slice of all the s received on inp channel before close. Unlike Done, a full slice is sent once, not just an event.

func Join ¶

func Join(out chan<- []byte, inp ...[]byte) chan struct{}

Join sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinBuffer ¶

func JoinBuffer(out chan<- bytes.Buffer, inp ...bytes.Buffer) chan struct{}

JoinBuffer sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinBufferChan ¶

func JoinBufferChan(out chan<- bytes.Buffer, inp <-chan bytes.Buffer) chan struct{}

JoinBufferChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinBufferSlice ¶

func JoinBufferSlice(out chan<- bytes.Buffer, inp ...[]bytes.Buffer) chan struct{}

JoinBufferSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByte ¶

func JoinByte(out chan<- byte, inp ...byte) chan struct{}

JoinByte sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteChan ¶

func JoinByteChan(out chan<- byte, inp <-chan byte) chan struct{}

JoinByteChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteReader ¶

func JoinByteReader(out chan<- io.ByteReader, inp ...io.ByteReader) chan struct{}

JoinByteReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteReaderChan ¶

func JoinByteReaderChan(out chan<- io.ByteReader, inp <-chan io.ByteReader) chan struct{}

JoinByteReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteReaderSlice ¶

func JoinByteReaderSlice(out chan<- io.ByteReader, inp ...[]io.ByteReader) chan struct{}

JoinByteReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteScanner ¶

func JoinByteScanner(out chan<- io.ByteScanner, inp ...io.ByteScanner) chan struct{}

JoinByteScanner sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteScannerChan ¶

func JoinByteScannerChan(out chan<- io.ByteScanner, inp <-chan io.ByteScanner) chan struct{}

JoinByteScannerChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteScannerSlice ¶

func JoinByteScannerSlice(out chan<- io.ByteScanner, inp ...[]io.ByteScanner) chan struct{}

JoinByteScannerSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteSlice ¶

func JoinByteSlice(out chan<- byte, inp ...[]byte) chan struct{}

JoinByteSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteWriter ¶

func JoinByteWriter(out chan<- io.ByteWriter, inp ...io.ByteWriter) chan struct{}

JoinByteWriter sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteWriterChan ¶

func JoinByteWriterChan(out chan<- io.ByteWriter, inp <-chan io.ByteWriter) chan struct{}

JoinByteWriterChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinByteWriterSlice ¶

func JoinByteWriterSlice(out chan<- io.ByteWriter, inp ...[]io.ByteWriter) chan struct{}

JoinByteWriterSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinChan ¶

func JoinChan(out chan<- []byte, inp <-chan []byte) chan struct{}

JoinChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReader ¶

func JoinReader(out chan<- bytes.Reader, inp ...bytes.Reader) chan struct{}

JoinReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderChan ¶

func JoinReaderChan(out chan<- bytes.Reader, inp <-chan bytes.Reader) chan struct{}

JoinReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinReaderSlice ¶

func JoinReaderSlice(out chan<- bytes.Reader, inp ...[]bytes.Reader) chan struct{}

JoinReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSlice ¶

func JoinSlice(out chan<- []byte, inp ...[][]byte) chan struct{}

JoinSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func MakeBufferChan ¶

func MakeBufferChan() chan bytes.Buffer

MakeBufferChan returns a new open channel (simply a 'chan bytes.Buffer' that is).

Note: No 'Buffer-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myBufferPipelineStartsHere := MakeBufferChan()
// ... lot's of code to design and build Your favourite "myBufferWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myBufferPipelineStartsHere <- drop
}
close(myBufferPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeBufferBuffer) the channel is unbuffered.

func MakeByteChan ¶

func MakeByteChan() chan byte

MakeByteChan returns a new open channel (simply a 'chan byte' that is).

Note: No 'Byte-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myBytePipelineStartsHere := MakeByteChan()
// ... lot's of code to design and build Your favourite "myByteWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myBytePipelineStartsHere <- drop
}
close(myBytePipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteBuffer) the channel is unbuffered.

func MakeByteReaderChan ¶

func MakeByteReaderChan() chan io.ByteReader

MakeByteReaderChan returns a new open channel (simply a 'chan io.ByteReader' that is).

Note: No 'ByteReader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myByteReaderPipelineStartsHere := MakeByteReaderChan()
// ... lot's of code to design and build Your favourite "myByteReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myByteReaderPipelineStartsHere <- drop
}
close(myByteReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteReaderBuffer) the channel is unbuffered.

func MakeByteScannerChan ¶

func MakeByteScannerChan() chan io.ByteScanner

MakeByteScannerChan returns a new open channel (simply a 'chan io.ByteScanner' that is).

Note: No 'ByteScanner-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myByteScannerPipelineStartsHere := MakeByteScannerChan()
// ... lot's of code to design and build Your favourite "myByteScannerWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myByteScannerPipelineStartsHere <- drop
}
close(myByteScannerPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteScannerBuffer) the channel is unbuffered.

func MakeByteWriterChan ¶

func MakeByteWriterChan() chan io.ByteWriter

MakeByteWriterChan returns a new open channel (simply a 'chan io.ByteWriter' that is).

Note: No 'ByteWriter-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myByteWriterPipelineStartsHere := MakeByteWriterChan()
// ... lot's of code to design and build Your favourite "myByteWriterWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myByteWriterPipelineStartsHere <- drop
}
close(myByteWriterPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeByteWriterBuffer) the channel is unbuffered.

func MakeChan ¶

func MakeChan() chan []byte

MakeChan returns a new open channel (simply a 'chan []byte' that is).

Note: No '-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myPipelineStartsHere := MakeChan()
// ... lot's of code to design and build Your favourite "myWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myPipelineStartsHere <- drop
}
close(myPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeBuffer) the channel is unbuffered.

func MakeReaderChan ¶

func MakeReaderChan() chan bytes.Reader

MakeReaderChan returns a new open channel (simply a 'chan bytes.Reader' that is).

Note: No 'Reader-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myReaderPipelineStartsHere := MakeReaderChan()
// ... lot's of code to design and build Your favourite "myReaderWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myReaderPipelineStartsHere <- drop
}
close(myReaderPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeReaderBuffer) the channel is unbuffered.

func PipeBuffer ¶

func PipeBuffer(inp <-chan []byte, cap int) chan []byte

PipeBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeBufferBuffer ¶

func PipeBufferBuffer(inp <-chan bytes.Buffer, cap int) chan bytes.Buffer

PipeBufferBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeBufferFork ¶

func PipeBufferFork(inp <-chan bytes.Buffer) (chan bytes.Buffer, chan bytes.Buffer)

PipeBufferFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeBufferFunc ¶

func PipeBufferFunc(inp <-chan bytes.Buffer, act func(a bytes.Buffer) bytes.Buffer) chan bytes.Buffer

PipeBufferFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeBufferMap for functional people, but 'map' has a very different meaning in go lang.

func PipeByteBuffer ¶

func PipeByteBuffer(inp <-chan byte, cap int) chan byte

PipeByteBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteFork ¶

func PipeByteFork(inp <-chan byte) (chan byte, chan byte)

PipeByteFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteFunc ¶

func PipeByteFunc(inp <-chan byte, act func(a byte) byte) chan byte

PipeByteFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteMap for functional people, but 'map' has a very different meaning in go lang.

func PipeByteReaderBuffer ¶

func PipeByteReaderBuffer(inp <-chan io.ByteReader, cap int) chan io.ByteReader

PipeByteReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteReaderFork ¶

func PipeByteReaderFork(inp <-chan io.ByteReader) (chan io.ByteReader, chan io.ByteReader)

PipeByteReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteReaderFunc ¶

func PipeByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader) io.ByteReader) chan io.ByteReader

PipeByteReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteReaderMap for functional people, but 'map' has a very different meaning in go lang.

func PipeByteScannerBuffer ¶

func PipeByteScannerBuffer(inp <-chan io.ByteScanner, cap int) chan io.ByteScanner

PipeByteScannerBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteScannerFork ¶

func PipeByteScannerFork(inp <-chan io.ByteScanner) (chan io.ByteScanner, chan io.ByteScanner)

PipeByteScannerFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteScannerFunc ¶

func PipeByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner) io.ByteScanner) chan io.ByteScanner

PipeByteScannerFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteScannerMap for functional people, but 'map' has a very different meaning in go lang.

func PipeByteWriterBuffer ¶

func PipeByteWriterBuffer(inp <-chan io.ByteWriter, cap int) chan io.ByteWriter

PipeByteWriterBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeByteWriterFork ¶

func PipeByteWriterFork(inp <-chan io.ByteWriter) (chan io.ByteWriter, chan io.ByteWriter)

PipeByteWriterFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeByteWriterFunc ¶

func PipeByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter) io.ByteWriter) chan io.ByteWriter

PipeByteWriterFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeByteWriterMap for functional people, but 'map' has a very different meaning in go lang.

func PipeFork ¶

func PipeFork(inp <-chan []byte) (chan []byte, chan []byte)

PipeFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeFunc ¶

func PipeFunc(inp <-chan []byte, act func(a []byte) []byte) chan []byte

PipeFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeMap for functional people, but 'map' has a very different meaning in go lang.

func PipeReaderBuffer ¶

func PipeReaderBuffer(inp <-chan bytes.Reader, cap int) chan bytes.Reader

PipeReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeReaderFork ¶

func PipeReaderFork(inp <-chan bytes.Reader) (chan bytes.Reader, chan bytes.Reader)

PipeReaderFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeReaderFunc ¶

func PipeReaderFunc(inp <-chan bytes.Reader, act func(a bytes.Reader) bytes.Reader) chan bytes.Reader

PipeReaderFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeReaderMap for functional people, but 'map' has a very different meaning in go lang.

func ReaderDaisy ¶

func ReaderDaisy(inp <-chan bytes.Reader, tube ReaderTube) (out <-chan bytes.Reader)

ReaderDaisy returns a channel to receive all inp after having passed thru tube.

func ReaderDaisyChain ¶

func ReaderDaisyChain(inp <-chan bytes.Reader, tubes ...ReaderTube) (out <-chan bytes.Reader)

ReaderDaisyChain returns a channel to receive all inp after having passed thru all tubes.

func SendProxy ¶

func SendProxy(out chan<- []byte) chan<- []byte

SendProxy returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyBuffer ¶

func SendProxyBuffer(out chan<- bytes.Buffer) chan<- bytes.Buffer

SendProxyBuffer returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyByte ¶

func SendProxyByte(out chan<- byte) chan<- byte

SendProxyByte returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyByteReader ¶

func SendProxyByteReader(out chan<- io.ByteReader) chan<- io.ByteReader

SendProxyByteReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyByteScanner ¶

func SendProxyByteScanner(out chan<- io.ByteScanner) chan<- io.ByteScanner

SendProxyByteScanner returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyByteWriter ¶

func SendProxyByteWriter(out chan<- io.ByteWriter) chan<- io.ByteWriter

SendProxyByteWriter returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyReader ¶

func SendProxyReader(out chan<- bytes.Reader) chan<- bytes.Reader

SendProxyReader returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

Types ¶

type BufferTube ¶

type BufferTube func(inp <-chan bytes.Buffer, out <-chan bytes.Buffer)

BufferTube is the signature for a pipe function.

type ByteReaderTube ¶

type ByteReaderTube func(inp <-chan io.ByteReader, out <-chan io.ByteReader)

ByteReaderTube is the signature for a pipe function.

type ByteScannerTube ¶

type ByteScannerTube func(inp <-chan io.ByteScanner, out <-chan io.ByteScanner)

ByteScannerTube is the signature for a pipe function.

type ByteTube ¶

type ByteTube func(inp <-chan byte, out <-chan byte)

ByteTube is the signature for a pipe function.

type ByteWriterTube ¶

type ByteWriterTube func(inp <-chan io.ByteWriter, out <-chan io.ByteWriter)

ByteWriterTube is the signature for a pipe function.

type ReaderTube ¶

type ReaderTube func(inp <-chan bytes.Reader, out <-chan bytes.Reader)

ReaderTube is the signature for a pipe function.

type Tube ¶

type Tube func(inp <-chan []byte, out <-chan []byte)

Tube is the signature for a pipe function.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL