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 ¶
const BufferCAP = 10
BufferCAP is the capacity of the buffered proxy channel
const BufferQUE = 16
BufferQUE is the allocated size of the circular queue
const ByteCAP = 10
ByteCAP is the capacity of the buffered proxy channel
const ByteQUE = 16
ByteQUE is the allocated size of the circular queue
const ByteReaderCAP = 10
ByteReaderCAP is the capacity of the buffered proxy channel
const ByteReaderQUE = 16
ByteReaderQUE is the allocated size of the circular queue
const ByteScannerCAP = 10
ByteScannerCAP is the capacity of the buffered proxy channel
const ByteScannerQUE = 16
ByteScannerQUE is the allocated size of the circular queue
const ByteWriterCAP = 10
ByteWriterCAP is the capacity of the buffered proxy channel
const ByteWriterQUE = 16
ByteWriterQUE is the allocated size of the circular queue
const CAP = 10
CAP is the capacity of the buffered proxy channel
const QUE = 16
QUE is the allocated size of the circular queue
const ReaderCAP = 10
ReaderCAP is the capacity of the buffered proxy channel
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 ByteDaisyChain ¶
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 ChanBuffer ¶
ChanBuffer returns a channel to receive all inputs before close.
func ChanBufferFuncErr ¶
ChanBufferFuncErr returns a channel to receive all results of act until err != nil before close.
func ChanBufferFuncNok ¶
ChanBufferFuncNok returns a channel to receive all results of act until nok before close.
func ChanBufferSlice ¶
ChanBufferSlice returns a channel to receive all inputs before close.
func ChanByteFuncErr ¶
ChanByteFuncErr returns a channel to receive all results of act until err != nil before close.
func ChanByteFuncNok ¶
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 ¶
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 ¶
ChanFuncErr returns a channel to receive all results of act until err != nil before close.
func ChanFuncNok ¶
ChanFuncNok returns a channel to receive all results of act until nok before close.
func ChanReader ¶
ChanReader returns a channel to receive all inputs before close.
func ChanReaderFuncErr ¶
ChanReaderFuncErr returns a channel to receive all results of act until err != nil before close.
func ChanReaderFuncNok ¶
ChanReaderFuncNok returns a channel to receive all results of act until nok before close.
func ChanReaderSlice ¶
ChanReaderSlice returns a channel to receive all inputs before close.
func DaisyChain ¶
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 ¶
DoneBuffer returns a channel to receive one signal before close after inp has been drained.
func DoneBufferFunc ¶
DoneBufferFunc returns a channel to receive one signal before close after act has been applied to all inp.
func DoneBufferSlice ¶
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 ¶
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 ¶
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 ¶
DoneFunc returns a channel to receive one signal before close after act has been applied to all inp.
func DoneReader ¶
DoneReader returns a channel to receive one signal before close after inp has been drained.
func DoneReaderFunc ¶
DoneReaderFunc returns a channel to receive one signal before close after act has been applied to all inp.
func DoneReaderSlice ¶
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 ¶
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 ¶
Join sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinBuffer ¶
JoinBuffer sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinBufferChan ¶
JoinBufferChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinBufferSlice ¶
JoinBufferSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinByte ¶
JoinByte sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinByteChan ¶
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 ¶
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 ¶
JoinChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinReader ¶
JoinReader sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinReaderChan ¶
JoinReaderChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinReaderSlice ¶
JoinReaderSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func JoinSlice ¶
JoinSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained
func MakeBufferChan ¶
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 ¶
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 ¶
PipeBuffer returns a buffered channel with capacity cap to receive all inp before close.
func PipeBufferBuffer ¶
PipeBufferBuffer returns a buffered channel with capacity cap to receive all inp before close.
func PipeBufferFork ¶
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 ¶
PipeByteBuffer returns a buffered channel with capacity cap to receive all inp before close.
func PipeByteFork ¶
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 ¶
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 ¶
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 ¶
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 ¶
PipeReaderBuffer returns a buffered channel with capacity cap to receive all inp before close.
func PipeReaderFork ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ByteWriterTube ¶
type ByteWriterTube func(inp <-chan io.ByteWriter, out <-chan io.ByteWriter)
ByteWriterTube is the signature for a pipe function.
type ReaderTube ¶
ReaderTube is the signature for a pipe function.
Source Files
¶
- Chan.dot.go
- ChanBuffer.dot.go
- ChanByte.dot.go
- ChanByteReader.dot.go
- ChanByteScanner.dot.go
- ChanByteWriter.dot.go
- ChanReader.dot.go
- SendBufferProxy.dot.go
- SendByteProxy.dot.go
- SendByteReaderProxy.dot.go
- SendByteScannerProxy.dot.go
- SendByteWriterProxy.dot.go
- SendProxy.dot.go
- SendReaderProxy.dot.go
- dot.go