io

package

v0.0.0-...-5012a73 Latest Latest Go to latest Published: Jun 20, 2019 License: MIT Imports: 2 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 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 ChanByteReader(inp ...io.ByteReader) (out <-chan io.ByteReader)
func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) (out <-chan io.ByteReader)
func ChanByteReaderFuncNok(act func() (io.ByteReader, bool)) (out <-chan io.ByteReader)
func ChanByteReaderSlice(inp ...[]io.ByteReader) (out <-chan io.ByteReader)
func ChanByteScanner(inp ...io.ByteScanner) (out <-chan io.ByteScanner)
func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) (out <-chan io.ByteScanner)
func ChanByteScannerFuncNok(act func() (io.ByteScanner, bool)) (out <-chan io.ByteScanner)
func ChanByteScannerSlice(inp ...[]io.ByteScanner) (out <-chan io.ByteScanner)
func ChanByteWriter(inp ...io.ByteWriter) (out <-chan io.ByteWriter)
func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) (out <-chan io.ByteWriter)
func ChanByteWriterFuncNok(act func() (io.ByteWriter, bool)) (out <-chan io.ByteWriter)
func ChanByteWriterSlice(inp ...[]io.ByteWriter) (out <-chan io.ByteWriter)
func ChanCloser(inp ...io.Closer) (out <-chan io.Closer)
func ChanCloserFuncErr(act func() (io.Closer, error)) (out <-chan io.Closer)
func ChanCloserFuncNok(act func() (io.Closer, bool)) (out <-chan io.Closer)
func ChanCloserSlice(inp ...[]io.Closer) (out <-chan io.Closer)
func ChanLimitedReader(inp ...*io.LimitedReader) (out <-chan *io.LimitedReader)
func ChanLimitedReaderFuncErr(act func() (*io.LimitedReader, error)) (out <-chan *io.LimitedReader)
func ChanLimitedReaderFuncNok(act func() (*io.LimitedReader, bool)) (out <-chan *io.LimitedReader)
func ChanLimitedReaderSlice(inp ...[]*io.LimitedReader) (out <-chan *io.LimitedReader)
func ChanPipeReader(inp ...*io.PipeReader) (out <-chan *io.PipeReader)
func ChanPipeReaderFuncErr(act func() (*io.PipeReader, error)) (out <-chan *io.PipeReader)
func ChanPipeReaderFuncNok(act func() (*io.PipeReader, bool)) (out <-chan *io.PipeReader)
func ChanPipeReaderSlice(inp ...[]*io.PipeReader) (out <-chan *io.PipeReader)
func ChanPipeWriter(inp ...*io.PipeWriter) (out <-chan *io.PipeWriter)
func ChanPipeWriterFuncErr(act func() (*io.PipeWriter, error)) (out <-chan *io.PipeWriter)
func ChanPipeWriterFuncNok(act func() (*io.PipeWriter, bool)) (out <-chan *io.PipeWriter)
func ChanPipeWriterSlice(inp ...[]*io.PipeWriter) (out <-chan *io.PipeWriter)
func ChanReadCloser(inp ...io.ReadCloser) (out <-chan io.ReadCloser)
func ChanReadCloserFuncErr(act func() (io.ReadCloser, error)) (out <-chan io.ReadCloser)
func ChanReadCloserFuncNok(act func() (io.ReadCloser, bool)) (out <-chan io.ReadCloser)
func ChanReadCloserSlice(inp ...[]io.ReadCloser) (out <-chan io.ReadCloser)
func ChanReadSeeker(inp ...io.ReadSeeker) (out <-chan io.ReadSeeker)
func ChanReadSeekerFuncErr(act func() (io.ReadSeeker, error)) (out <-chan io.ReadSeeker)
func ChanReadSeekerFuncNok(act func() (io.ReadSeeker, bool)) (out <-chan io.ReadSeeker)
func ChanReadSeekerSlice(inp ...[]io.ReadSeeker) (out <-chan io.ReadSeeker)
func ChanReadWriteCloser(inp ...io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)
func ChanReadWriteCloserFuncErr(act func() (io.ReadWriteCloser, error)) (out <-chan io.ReadWriteCloser)
func ChanReadWriteCloserFuncNok(act func() (io.ReadWriteCloser, bool)) (out <-chan io.ReadWriteCloser)
func ChanReadWriteCloserSlice(inp ...[]io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)
func ChanReadWriteSeeker(inp ...io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)
func ChanReadWriteSeekerFuncErr(act func() (io.ReadWriteSeeker, error)) (out <-chan io.ReadWriteSeeker)
func ChanReadWriteSeekerFuncNok(act func() (io.ReadWriteSeeker, bool)) (out <-chan io.ReadWriteSeeker)
func ChanReadWriteSeekerSlice(inp ...[]io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)
func ChanReadWriter(inp ...io.ReadWriter) (out <-chan io.ReadWriter)
func ChanReadWriterFuncErr(act func() (io.ReadWriter, error)) (out <-chan io.ReadWriter)
func ChanReadWriterFuncNok(act func() (io.ReadWriter, bool)) (out <-chan io.ReadWriter)
func ChanReadWriterSlice(inp ...[]io.ReadWriter) (out <-chan io.ReadWriter)
func ChanReader(inp ...io.Reader) (out <-chan io.Reader)
func ChanReaderAt(inp ...io.ReaderAt) (out <-chan io.ReaderAt)
func ChanReaderAtFuncErr(act func() (io.ReaderAt, error)) (out <-chan io.ReaderAt)
func ChanReaderAtFuncNok(act func() (io.ReaderAt, bool)) (out <-chan io.ReaderAt)
func ChanReaderAtSlice(inp ...[]io.ReaderAt) (out <-chan io.ReaderAt)
func ChanReaderFrom(inp ...io.ReaderFrom) (out <-chan io.ReaderFrom)
func ChanReaderFromFuncErr(act func() (io.ReaderFrom, error)) (out <-chan io.ReaderFrom)
func ChanReaderFromFuncNok(act func() (io.ReaderFrom, bool)) (out <-chan io.ReaderFrom)
func ChanReaderFromSlice(inp ...[]io.ReaderFrom) (out <-chan io.ReaderFrom)
func ChanReaderFuncErr(act func() (io.Reader, error)) (out <-chan io.Reader)
func ChanReaderFuncNok(act func() (io.Reader, bool)) (out <-chan io.Reader)
func ChanReaderSlice(inp ...[]io.Reader) (out <-chan io.Reader)
func ChanRuneReader(inp ...io.RuneReader) (out <-chan io.RuneReader)
func ChanRuneReaderFuncErr(act func() (io.RuneReader, error)) (out <-chan io.RuneReader)
func ChanRuneReaderFuncNok(act func() (io.RuneReader, bool)) (out <-chan io.RuneReader)
func ChanRuneReaderSlice(inp ...[]io.RuneReader) (out <-chan io.RuneReader)
func ChanRuneScanner(inp ...io.RuneScanner) (out <-chan io.RuneScanner)
func ChanRuneScannerFuncErr(act func() (io.RuneScanner, error)) (out <-chan io.RuneScanner)
func ChanRuneScannerFuncNok(act func() (io.RuneScanner, bool)) (out <-chan io.RuneScanner)
func ChanRuneScannerSlice(inp ...[]io.RuneScanner) (out <-chan io.RuneScanner)
func ChanSectionReader(inp ...*io.SectionReader) (out <-chan *io.SectionReader)
func ChanSectionReaderFuncErr(act func() (*io.SectionReader, error)) (out <-chan *io.SectionReader)
func ChanSectionReaderFuncNok(act func() (*io.SectionReader, bool)) (out <-chan *io.SectionReader)
func ChanSectionReaderSlice(inp ...[]*io.SectionReader) (out <-chan *io.SectionReader)
func ChanSeeker(inp ...io.Seeker) (out <-chan io.Seeker)
func ChanSeekerFuncErr(act func() (io.Seeker, error)) (out <-chan io.Seeker)
func ChanSeekerFuncNok(act func() (io.Seeker, bool)) (out <-chan io.Seeker)
func ChanSeekerSlice(inp ...[]io.Seeker) (out <-chan io.Seeker)
func ChanWriteCloser(inp ...io.WriteCloser) (out <-chan io.WriteCloser)
func ChanWriteCloserFuncErr(act func() (io.WriteCloser, error)) (out <-chan io.WriteCloser)
func ChanWriteCloserFuncNok(act func() (io.WriteCloser, bool)) (out <-chan io.WriteCloser)
func ChanWriteCloserSlice(inp ...[]io.WriteCloser) (out <-chan io.WriteCloser)
func ChanWriteSeeker(inp ...io.WriteSeeker) (out <-chan io.WriteSeeker)
func ChanWriteSeekerFuncErr(act func() (io.WriteSeeker, error)) (out <-chan io.WriteSeeker)
func ChanWriteSeekerFuncNok(act func() (io.WriteSeeker, bool)) (out <-chan io.WriteSeeker)
func ChanWriteSeekerSlice(inp ...[]io.WriteSeeker) (out <-chan io.WriteSeeker)
func ChanWriter(inp ...io.Writer) (out <-chan io.Writer)
func ChanWriterAt(inp ...io.WriterAt) (out <-chan io.WriterAt)
func ChanWriterAtFuncErr(act func() (io.WriterAt, error)) (out <-chan io.WriterAt)
func ChanWriterAtFuncNok(act func() (io.WriterAt, bool)) (out <-chan io.WriterAt)
func ChanWriterAtSlice(inp ...[]io.WriterAt) (out <-chan io.WriterAt)
func ChanWriterFuncErr(act func() (io.Writer, error)) (out <-chan io.Writer)
func ChanWriterFuncNok(act func() (io.Writer, bool)) (out <-chan io.Writer)
func ChanWriterSlice(inp ...[]io.Writer) (out <-chan io.Writer)
func ChanWriterTo(inp ...io.WriterTo) (out <-chan io.WriterTo)
func ChanWriterToFuncErr(act func() (io.WriterTo, error)) (out <-chan io.WriterTo)
func ChanWriterToFuncNok(act func() (io.WriterTo, bool)) (out <-chan io.WriterTo)
func ChanWriterToSlice(inp ...[]io.WriterTo) (out <-chan io.WriterTo)
func CloserDaisy(inp <-chan io.Closer, tube CloserTube) (out <-chan io.Closer)
func CloserDaisyChain(inp <-chan io.Closer, tubes ...CloserTube) (out <-chan io.Closer)
func DoneByteReader(inp <-chan io.ByteReader) (done <-chan struct{})
func DoneByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader)) (out <-chan struct{})
func DoneByteReaderSlice(inp <-chan io.ByteReader) (done <-chan ([]io.ByteReader))
func DoneByteScanner(inp <-chan io.ByteScanner) (done <-chan struct{})
func DoneByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner)) (out <-chan struct{})
func DoneByteScannerSlice(inp <-chan io.ByteScanner) (done <-chan ([]io.ByteScanner))
func DoneByteWriter(inp <-chan io.ByteWriter) (done <-chan struct{})
func DoneByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter)) (out <-chan struct{})
func DoneByteWriterSlice(inp <-chan io.ByteWriter) (done <-chan ([]io.ByteWriter))
func DoneCloser(inp <-chan io.Closer) (done <-chan struct{})
func DoneCloserFunc(inp <-chan io.Closer, act func(a io.Closer)) (out <-chan struct{})
func DoneCloserSlice(inp <-chan io.Closer) (done <-chan ([]io.Closer))
func DoneLimitedReader(inp <-chan *io.LimitedReader) (done <-chan struct{})
func DoneLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader)) (out <-chan struct{})
func DoneLimitedReaderSlice(inp <-chan *io.LimitedReader) (done <-chan ([]*io.LimitedReader))
func DonePipeReader(inp <-chan *io.PipeReader) (done <-chan struct{})
func DonePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader)) (out <-chan struct{})
func DonePipeReaderSlice(inp <-chan *io.PipeReader) (done <-chan ([]*io.PipeReader))
func DonePipeWriter(inp <-chan *io.PipeWriter) (done <-chan struct{})
func DonePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter)) (out <-chan struct{})
func DonePipeWriterSlice(inp <-chan *io.PipeWriter) (done <-chan ([]*io.PipeWriter))
func DoneReadCloser(inp <-chan io.ReadCloser) (done <-chan struct{})
func DoneReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser)) (out <-chan struct{})
func DoneReadCloserSlice(inp <-chan io.ReadCloser) (done <-chan ([]io.ReadCloser))
func DoneReadSeeker(inp <-chan io.ReadSeeker) (done <-chan struct{})
func DoneReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker)) (out <-chan struct{})
func DoneReadSeekerSlice(inp <-chan io.ReadSeeker) (done <-chan ([]io.ReadSeeker))
func DoneReadWriteCloser(inp <-chan io.ReadWriteCloser) (done <-chan struct{})
func DoneReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, act func(a io.ReadWriteCloser)) (out <-chan struct{})
func DoneReadWriteCloserSlice(inp <-chan io.ReadWriteCloser) (done <-chan ([]io.ReadWriteCloser))
func DoneReadWriteSeeker(inp <-chan io.ReadWriteSeeker) (done <-chan struct{})
func DoneReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, act func(a io.ReadWriteSeeker)) (out <-chan struct{})
func DoneReadWriteSeekerSlice(inp <-chan io.ReadWriteSeeker) (done <-chan ([]io.ReadWriteSeeker))
func DoneReadWriter(inp <-chan io.ReadWriter) (done <-chan struct{})
func DoneReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter)) (out <-chan struct{})
func DoneReadWriterSlice(inp <-chan io.ReadWriter) (done <-chan ([]io.ReadWriter))
func DoneReader(inp <-chan io.Reader) (done <-chan struct{})
func DoneReaderAt(inp <-chan io.ReaderAt) (done <-chan struct{})
func DoneReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt)) (out <-chan struct{})
func DoneReaderAtSlice(inp <-chan io.ReaderAt) (done <-chan ([]io.ReaderAt))
func DoneReaderFrom(inp <-chan io.ReaderFrom) (done <-chan struct{})
func DoneReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom)) (out <-chan struct{})
func DoneReaderFromSlice(inp <-chan io.ReaderFrom) (done <-chan ([]io.ReaderFrom))
func DoneReaderFunc(inp <-chan io.Reader, act func(a io.Reader)) (out <-chan struct{})
func DoneReaderSlice(inp <-chan io.Reader) (done <-chan ([]io.Reader))
func DoneRuneReader(inp <-chan io.RuneReader) (done <-chan struct{})
func DoneRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader)) (out <-chan struct{})
func DoneRuneReaderSlice(inp <-chan io.RuneReader) (done <-chan ([]io.RuneReader))
func DoneRuneScanner(inp <-chan io.RuneScanner) (done <-chan struct{})
func DoneRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner)) (out <-chan struct{})
func DoneRuneScannerSlice(inp <-chan io.RuneScanner) (done <-chan ([]io.RuneScanner))
func DoneSectionReader(inp <-chan *io.SectionReader) (done <-chan struct{})
func DoneSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader)) (out <-chan struct{})
func DoneSectionReaderSlice(inp <-chan *io.SectionReader) (done <-chan ([]*io.SectionReader))
func DoneSeeker(inp <-chan io.Seeker) (done <-chan struct{})
func DoneSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker)) (out <-chan struct{})
func DoneSeekerSlice(inp <-chan io.Seeker) (done <-chan ([]io.Seeker))
func DoneWriteCloser(inp <-chan io.WriteCloser) (done <-chan struct{})
func DoneWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser)) (out <-chan struct{})
func DoneWriteCloserSlice(inp <-chan io.WriteCloser) (done <-chan ([]io.WriteCloser))
func DoneWriteSeeker(inp <-chan io.WriteSeeker) (done <-chan struct{})
func DoneWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker)) (out <-chan struct{})
func DoneWriteSeekerSlice(inp <-chan io.WriteSeeker) (done <-chan ([]io.WriteSeeker))
func DoneWriter(inp <-chan io.Writer) (done <-chan struct{})
func DoneWriterAt(inp <-chan io.WriterAt) (done <-chan struct{})
func DoneWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt)) (out <-chan struct{})
func DoneWriterAtSlice(inp <-chan io.WriterAt) (done <-chan ([]io.WriterAt))
func DoneWriterFunc(inp <-chan io.Writer, act func(a io.Writer)) (out <-chan struct{})
func DoneWriterSlice(inp <-chan io.Writer) (done <-chan ([]io.Writer))
func DoneWriterTo(inp <-chan io.WriterTo) (done <-chan struct{})
func DoneWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo)) (out <-chan struct{})
func DoneWriterToSlice(inp <-chan io.WriterTo) (done <-chan ([]io.WriterTo))
func JoinByteReader(out chan<- io.ByteReader, inp ...io.ByteReader) (done <-chan struct{})
func JoinByteReaderChan(out chan<- io.ByteReader, inp <-chan io.ByteReader) (done <-chan struct{})
func JoinByteReaderSlice(out chan<- io.ByteReader, inp ...[]io.ByteReader) (done <-chan struct{})
func JoinByteScanner(out chan<- io.ByteScanner, inp ...io.ByteScanner) (done <-chan struct{})
func JoinByteScannerChan(out chan<- io.ByteScanner, inp <-chan io.ByteScanner) (done <-chan struct{})
func JoinByteScannerSlice(out chan<- io.ByteScanner, inp ...[]io.ByteScanner) (done <-chan struct{})
func JoinByteWriter(out chan<- io.ByteWriter, inp ...io.ByteWriter) (done <-chan struct{})
func JoinByteWriterChan(out chan<- io.ByteWriter, inp <-chan io.ByteWriter) (done <-chan struct{})
func JoinByteWriterSlice(out chan<- io.ByteWriter, inp ...[]io.ByteWriter) (done <-chan struct{})
func JoinCloser(out chan<- io.Closer, inp ...io.Closer) (done <-chan struct{})
func JoinCloserChan(out chan<- io.Closer, inp <-chan io.Closer) (done <-chan struct{})
func JoinCloserSlice(out chan<- io.Closer, inp ...[]io.Closer) (done <-chan struct{})
func JoinLimitedReader(out chan<- *io.LimitedReader, inp ...*io.LimitedReader) (done <-chan struct{})
func JoinLimitedReaderChan(out chan<- *io.LimitedReader, inp <-chan *io.LimitedReader) (done <-chan struct{})
func JoinLimitedReaderSlice(out chan<- *io.LimitedReader, inp ...[]*io.LimitedReader) (done <-chan struct{})
func JoinPipeReader(out chan<- *io.PipeReader, inp ...*io.PipeReader) (done <-chan struct{})
func JoinPipeReaderChan(out chan<- *io.PipeReader, inp <-chan *io.PipeReader) (done <-chan struct{})
func JoinPipeReaderSlice(out chan<- *io.PipeReader, inp ...[]*io.PipeReader) (done <-chan struct{})
func JoinPipeWriter(out chan<- *io.PipeWriter, inp ...*io.PipeWriter) (done <-chan struct{})
func JoinPipeWriterChan(out chan<- *io.PipeWriter, inp <-chan *io.PipeWriter) (done <-chan struct{})
func JoinPipeWriterSlice(out chan<- *io.PipeWriter, inp ...[]*io.PipeWriter) (done <-chan struct{})
func JoinReadCloser(out chan<- io.ReadCloser, inp ...io.ReadCloser) (done <-chan struct{})
func JoinReadCloserChan(out chan<- io.ReadCloser, inp <-chan io.ReadCloser) (done <-chan struct{})
func JoinReadCloserSlice(out chan<- io.ReadCloser, inp ...[]io.ReadCloser) (done <-chan struct{})
func JoinReadSeeker(out chan<- io.ReadSeeker, inp ...io.ReadSeeker) (done <-chan struct{})
func JoinReadSeekerChan(out chan<- io.ReadSeeker, inp <-chan io.ReadSeeker) (done <-chan struct{})
func JoinReadSeekerSlice(out chan<- io.ReadSeeker, inp ...[]io.ReadSeeker) (done <-chan struct{})
func JoinReadWriteCloser(out chan<- io.ReadWriteCloser, inp ...io.ReadWriteCloser) (done <-chan struct{})
func JoinReadWriteCloserChan(out chan<- io.ReadWriteCloser, inp <-chan io.ReadWriteCloser) (done <-chan struct{})
func JoinReadWriteCloserSlice(out chan<- io.ReadWriteCloser, inp ...[]io.ReadWriteCloser) (done <-chan struct{})
func JoinReadWriteSeeker(out chan<- io.ReadWriteSeeker, inp ...io.ReadWriteSeeker) (done <-chan struct{})
func JoinReadWriteSeekerChan(out chan<- io.ReadWriteSeeker, inp <-chan io.ReadWriteSeeker) (done <-chan struct{})
func JoinReadWriteSeekerSlice(out chan<- io.ReadWriteSeeker, inp ...[]io.ReadWriteSeeker) (done <-chan struct{})
func JoinReadWriter(out chan<- io.ReadWriter, inp ...io.ReadWriter) (done <-chan struct{})
func JoinReadWriterChan(out chan<- io.ReadWriter, inp <-chan io.ReadWriter) (done <-chan struct{})
func JoinReadWriterSlice(out chan<- io.ReadWriter, inp ...[]io.ReadWriter) (done <-chan struct{})
func JoinReader(out chan<- io.Reader, inp ...io.Reader) (done <-chan struct{})
func JoinReaderAt(out chan<- io.ReaderAt, inp ...io.ReaderAt) (done <-chan struct{})
func JoinReaderAtChan(out chan<- io.ReaderAt, inp <-chan io.ReaderAt) (done <-chan struct{})
func JoinReaderAtSlice(out chan<- io.ReaderAt, inp ...[]io.ReaderAt) (done <-chan struct{})
func JoinReaderChan(out chan<- io.Reader, inp <-chan io.Reader) (done <-chan struct{})
func JoinReaderFrom(out chan<- io.ReaderFrom, inp ...io.ReaderFrom) (done <-chan struct{})
func JoinReaderFromChan(out chan<- io.ReaderFrom, inp <-chan io.ReaderFrom) (done <-chan struct{})
func JoinReaderFromSlice(out chan<- io.ReaderFrom, inp ...[]io.ReaderFrom) (done <-chan struct{})
func JoinReaderSlice(out chan<- io.Reader, inp ...[]io.Reader) (done <-chan struct{})
func JoinRuneReader(out chan<- io.RuneReader, inp ...io.RuneReader) (done <-chan struct{})
func JoinRuneReaderChan(out chan<- io.RuneReader, inp <-chan io.RuneReader) (done <-chan struct{})
func JoinRuneReaderSlice(out chan<- io.RuneReader, inp ...[]io.RuneReader) (done <-chan struct{})
func JoinRuneScanner(out chan<- io.RuneScanner, inp ...io.RuneScanner) (done <-chan struct{})
func JoinRuneScannerChan(out chan<- io.RuneScanner, inp <-chan io.RuneScanner) (done <-chan struct{})
func JoinRuneScannerSlice(out chan<- io.RuneScanner, inp ...[]io.RuneScanner) (done <-chan struct{})
func JoinSectionReader(out chan<- *io.SectionReader, inp ...*io.SectionReader) (done <-chan struct{})
func JoinSectionReaderChan(out chan<- *io.SectionReader, inp <-chan *io.SectionReader) (done <-chan struct{})
func JoinSectionReaderSlice(out chan<- *io.SectionReader, inp ...[]*io.SectionReader) (done <-chan struct{})
func JoinSeeker(out chan<- io.Seeker, inp ...io.Seeker) (done <-chan struct{})
func JoinSeekerChan(out chan<- io.Seeker, inp <-chan io.Seeker) (done <-chan struct{})
func JoinSeekerSlice(out chan<- io.Seeker, inp ...[]io.Seeker) (done <-chan struct{})
func JoinWriteCloser(out chan<- io.WriteCloser, inp ...io.WriteCloser) (done <-chan struct{})
func JoinWriteCloserChan(out chan<- io.WriteCloser, inp <-chan io.WriteCloser) (done <-chan struct{})
func JoinWriteCloserSlice(out chan<- io.WriteCloser, inp ...[]io.WriteCloser) (done <-chan struct{})
func JoinWriteSeeker(out chan<- io.WriteSeeker, inp ...io.WriteSeeker) (done <-chan struct{})
func JoinWriteSeekerChan(out chan<- io.WriteSeeker, inp <-chan io.WriteSeeker) (done <-chan struct{})
func JoinWriteSeekerSlice(out chan<- io.WriteSeeker, inp ...[]io.WriteSeeker) (done <-chan struct{})
func JoinWriter(out chan<- io.Writer, inp ...io.Writer) (done <-chan struct{})
func JoinWriterAt(out chan<- io.WriterAt, inp ...io.WriterAt) (done <-chan struct{})
func JoinWriterAtChan(out chan<- io.WriterAt, inp <-chan io.WriterAt) (done <-chan struct{})
func JoinWriterAtSlice(out chan<- io.WriterAt, inp ...[]io.WriterAt) (done <-chan struct{})
func JoinWriterChan(out chan<- io.Writer, inp <-chan io.Writer) (done <-chan struct{})
func JoinWriterSlice(out chan<- io.Writer, inp ...[]io.Writer) (done <-chan struct{})
func JoinWriterTo(out chan<- io.WriterTo, inp ...io.WriterTo) (done <-chan struct{})
func JoinWriterToChan(out chan<- io.WriterTo, inp <-chan io.WriterTo) (done <-chan struct{})
func JoinWriterToSlice(out chan<- io.WriterTo, inp ...[]io.WriterTo) (done <-chan struct{})
func LimitedReaderDaisy(inp <-chan *io.LimitedReader, tube LimitedReaderTube) (out <-chan *io.LimitedReader)
func LimitedReaderDaisyChain(inp <-chan *io.LimitedReader, tubes ...LimitedReaderTube) (out <-chan *io.LimitedReader)
func MakeByteReaderChan() (out chan io.ByteReader)
func MakeByteScannerChan() (out chan io.ByteScanner)
func MakeByteWriterChan() (out chan io.ByteWriter)
func MakeCloserChan() (out chan io.Closer)
func MakeLimitedReaderChan() (out chan *io.LimitedReader)
func MakePipeReaderChan() (out chan *io.PipeReader)
func MakePipeWriterChan() (out chan *io.PipeWriter)
func MakeReadCloserChan() (out chan io.ReadCloser)
func MakeReadSeekerChan() (out chan io.ReadSeeker)
func MakeReadWriteCloserChan() (out chan io.ReadWriteCloser)
func MakeReadWriteSeekerChan() (out chan io.ReadWriteSeeker)
func MakeReadWriterChan() (out chan io.ReadWriter)
func MakeReaderAtChan() (out chan io.ReaderAt)
func MakeReaderChan() (out chan io.Reader)
func MakeReaderFromChan() (out chan io.ReaderFrom)
func MakeRuneReaderChan() (out chan io.RuneReader)
func MakeRuneScannerChan() (out chan io.RuneScanner)
func MakeSectionReaderChan() (out chan *io.SectionReader)
func MakeSeekerChan() (out chan io.Seeker)
func MakeWriteCloserChan() (out chan io.WriteCloser)
func MakeWriteSeekerChan() (out chan io.WriteSeeker)
func MakeWriterAtChan() (out chan io.WriterAt)
func MakeWriterChan() (out chan io.Writer)
func MakeWriterToChan() (out chan io.WriterTo)
func PipeByteReaderBuffer(inp <-chan io.ByteReader, cap int) (out <-chan io.ByteReader)
func PipeByteReaderFork(inp <-chan io.ByteReader) (out1, out2 <-chan io.ByteReader)
func PipeByteReaderFunc(inp <-chan io.ByteReader, act func(a io.ByteReader) io.ByteReader) (out <-chan io.ByteReader)
func PipeByteScannerBuffer(inp <-chan io.ByteScanner, cap int) (out <-chan io.ByteScanner)
func PipeByteScannerFork(inp <-chan io.ByteScanner) (out1, out2 <-chan io.ByteScanner)
func PipeByteScannerFunc(inp <-chan io.ByteScanner, act func(a io.ByteScanner) io.ByteScanner) (out <-chan io.ByteScanner)
func PipeByteWriterBuffer(inp <-chan io.ByteWriter, cap int) (out <-chan io.ByteWriter)
func PipeByteWriterFork(inp <-chan io.ByteWriter) (out1, out2 <-chan io.ByteWriter)
func PipeByteWriterFunc(inp <-chan io.ByteWriter, act func(a io.ByteWriter) io.ByteWriter) (out <-chan io.ByteWriter)
func PipeCloserBuffer(inp <-chan io.Closer, cap int) (out <-chan io.Closer)
func PipeCloserFork(inp <-chan io.Closer) (out1, out2 <-chan io.Closer)
func PipeCloserFunc(inp <-chan io.Closer, act func(a io.Closer) io.Closer) (out <-chan io.Closer)
func PipeLimitedReaderBuffer(inp <-chan *io.LimitedReader, cap int) (out <-chan *io.LimitedReader)
func PipeLimitedReaderFork(inp <-chan *io.LimitedReader) (out1, out2 <-chan *io.LimitedReader)
func PipeLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader) *io.LimitedReader) (out <-chan *io.LimitedReader)
func PipePipeReaderBuffer(inp <-chan *io.PipeReader, cap int) (out <-chan *io.PipeReader)
func PipePipeReaderFork(inp <-chan *io.PipeReader) (out1, out2 <-chan *io.PipeReader)
func PipePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader) *io.PipeReader) (out <-chan *io.PipeReader)
func PipePipeWriterBuffer(inp <-chan *io.PipeWriter, cap int) (out <-chan *io.PipeWriter)
func PipePipeWriterFork(inp <-chan *io.PipeWriter) (out1, out2 <-chan *io.PipeWriter)
func PipePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter) *io.PipeWriter) (out <-chan *io.PipeWriter)
func PipeReadCloserBuffer(inp <-chan io.ReadCloser, cap int) (out <-chan io.ReadCloser)
func PipeReadCloserFork(inp <-chan io.ReadCloser) (out1, out2 <-chan io.ReadCloser)
func PipeReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser) io.ReadCloser) (out <-chan io.ReadCloser)
func PipeReadSeekerBuffer(inp <-chan io.ReadSeeker, cap int) (out <-chan io.ReadSeeker)
func PipeReadSeekerFork(inp <-chan io.ReadSeeker) (out1, out2 <-chan io.ReadSeeker)
func PipeReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker) io.ReadSeeker) (out <-chan io.ReadSeeker)
func PipeReadWriteCloserBuffer(inp <-chan io.ReadWriteCloser, cap int) (out <-chan io.ReadWriteCloser)
func PipeReadWriteCloserFork(inp <-chan io.ReadWriteCloser) (out1, out2 <-chan io.ReadWriteCloser)
func PipeReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, ...) (out <-chan io.ReadWriteCloser)
func PipeReadWriteSeekerBuffer(inp <-chan io.ReadWriteSeeker, cap int) (out <-chan io.ReadWriteSeeker)
func PipeReadWriteSeekerFork(inp <-chan io.ReadWriteSeeker) (out1, out2 <-chan io.ReadWriteSeeker)
func PipeReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, ...) (out <-chan io.ReadWriteSeeker)
func PipeReadWriterBuffer(inp <-chan io.ReadWriter, cap int) (out <-chan io.ReadWriter)
func PipeReadWriterFork(inp <-chan io.ReadWriter) (out1, out2 <-chan io.ReadWriter)
func PipeReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter) io.ReadWriter) (out <-chan io.ReadWriter)
func PipeReaderAtBuffer(inp <-chan io.ReaderAt, cap int) (out <-chan io.ReaderAt)
func PipeReaderAtFork(inp <-chan io.ReaderAt) (out1, out2 <-chan io.ReaderAt)
func PipeReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt) io.ReaderAt) (out <-chan io.ReaderAt)
func PipeReaderBuffer(inp <-chan io.Reader, cap int) (out <-chan io.Reader)
func PipeReaderDaisy(inp <-chan *io.PipeReader, tube PipeReaderTube) (out <-chan *io.PipeReader)
func PipeReaderDaisyChain(inp <-chan *io.PipeReader, tubes ...PipeReaderTube) (out <-chan *io.PipeReader)
func PipeReaderFork(inp <-chan io.Reader) (out1, out2 <-chan io.Reader)
func PipeReaderFromBuffer(inp <-chan io.ReaderFrom, cap int) (out <-chan io.ReaderFrom)
func PipeReaderFromFork(inp <-chan io.ReaderFrom) (out1, out2 <-chan io.ReaderFrom)
func PipeReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom) io.ReaderFrom) (out <-chan io.ReaderFrom)
func PipeReaderFunc(inp <-chan io.Reader, act func(a io.Reader) io.Reader) (out <-chan io.Reader)
func PipeRuneReaderBuffer(inp <-chan io.RuneReader, cap int) (out <-chan io.RuneReader)
func PipeRuneReaderFork(inp <-chan io.RuneReader) (out1, out2 <-chan io.RuneReader)
func PipeRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader) io.RuneReader) (out <-chan io.RuneReader)
func PipeRuneScannerBuffer(inp <-chan io.RuneScanner, cap int) (out <-chan io.RuneScanner)
func PipeRuneScannerFork(inp <-chan io.RuneScanner) (out1, out2 <-chan io.RuneScanner)
func PipeRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner) io.RuneScanner) (out <-chan io.RuneScanner)
func PipeSectionReaderBuffer(inp <-chan *io.SectionReader, cap int) (out <-chan *io.SectionReader)
func PipeSectionReaderFork(inp <-chan *io.SectionReader) (out1, out2 <-chan *io.SectionReader)
func PipeSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader) *io.SectionReader) (out <-chan *io.SectionReader)
func PipeSeekerBuffer(inp <-chan io.Seeker, cap int) (out <-chan io.Seeker)
func PipeSeekerFork(inp <-chan io.Seeker) (out1, out2 <-chan io.Seeker)
func PipeSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker) io.Seeker) (out <-chan io.Seeker)
func PipeWriteCloserBuffer(inp <-chan io.WriteCloser, cap int) (out <-chan io.WriteCloser)
func PipeWriteCloserFork(inp <-chan io.WriteCloser) (out1, out2 <-chan io.WriteCloser)
func PipeWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser) io.WriteCloser) (out <-chan io.WriteCloser)
func PipeWriteSeekerBuffer(inp <-chan io.WriteSeeker, cap int) (out <-chan io.WriteSeeker)
func PipeWriteSeekerFork(inp <-chan io.WriteSeeker) (out1, out2 <-chan io.WriteSeeker)
func PipeWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker) io.WriteSeeker) (out <-chan io.WriteSeeker)
func PipeWriterAtBuffer(inp <-chan io.WriterAt, cap int) (out <-chan io.WriterAt)
func PipeWriterAtFork(inp <-chan io.WriterAt) (out1, out2 <-chan io.WriterAt)
func PipeWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt) io.WriterAt) (out <-chan io.WriterAt)
func PipeWriterBuffer(inp <-chan io.Writer, cap int) (out <-chan io.Writer)
func PipeWriterDaisy(inp <-chan *io.PipeWriter, tube PipeWriterTube) (out <-chan *io.PipeWriter)
func PipeWriterDaisyChain(inp <-chan *io.PipeWriter, tubes ...PipeWriterTube) (out <-chan *io.PipeWriter)
func PipeWriterFork(inp <-chan io.Writer) (out1, out2 <-chan io.Writer)
func PipeWriterFunc(inp <-chan io.Writer, act func(a io.Writer) io.Writer) (out <-chan io.Writer)
func PipeWriterToBuffer(inp <-chan io.WriterTo, cap int) (out <-chan io.WriterTo)
func PipeWriterToFork(inp <-chan io.WriterTo) (out1, out2 <-chan io.WriterTo)
func PipeWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo) io.WriterTo) (out <-chan io.WriterTo)
func ReadCloserDaisy(inp <-chan io.ReadCloser, tube ReadCloserTube) (out <-chan io.ReadCloser)
func ReadCloserDaisyChain(inp <-chan io.ReadCloser, tubes ...ReadCloserTube) (out <-chan io.ReadCloser)
func ReadSeekerDaisy(inp <-chan io.ReadSeeker, tube ReadSeekerTube) (out <-chan io.ReadSeeker)
func ReadSeekerDaisyChain(inp <-chan io.ReadSeeker, tubes ...ReadSeekerTube) (out <-chan io.ReadSeeker)
func ReadWriteCloserDaisy(inp <-chan io.ReadWriteCloser, tube ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)
func ReadWriteCloserDaisyChain(inp <-chan io.ReadWriteCloser, tubes ...ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)
func ReadWriteSeekerDaisy(inp <-chan io.ReadWriteSeeker, tube ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)
func ReadWriteSeekerDaisyChain(inp <-chan io.ReadWriteSeeker, tubes ...ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)
func ReadWriterDaisy(inp <-chan io.ReadWriter, tube ReadWriterTube) (out <-chan io.ReadWriter)
func ReadWriterDaisyChain(inp <-chan io.ReadWriter, tubes ...ReadWriterTube) (out <-chan io.ReadWriter)
func ReaderAtDaisy(inp <-chan io.ReaderAt, tube ReaderAtTube) (out <-chan io.ReaderAt)
func ReaderAtDaisyChain(inp <-chan io.ReaderAt, tubes ...ReaderAtTube) (out <-chan io.ReaderAt)
func ReaderDaisy(inp <-chan io.Reader, tube ReaderTube) (out <-chan io.Reader)
func ReaderDaisyChain(inp <-chan io.Reader, tubes ...ReaderTube) (out <-chan io.Reader)
func ReaderFromDaisy(inp <-chan io.ReaderFrom, tube ReaderFromTube) (out <-chan io.ReaderFrom)
func ReaderFromDaisyChain(inp <-chan io.ReaderFrom, tubes ...ReaderFromTube) (out <-chan io.ReaderFrom)
func RuneReaderDaisy(inp <-chan io.RuneReader, tube RuneReaderTube) (out <-chan io.RuneReader)
func RuneReaderDaisyChain(inp <-chan io.RuneReader, tubes ...RuneReaderTube) (out <-chan io.RuneReader)
func RuneScannerDaisy(inp <-chan io.RuneScanner, tube RuneScannerTube) (out <-chan io.RuneScanner)
func RuneScannerDaisyChain(inp <-chan io.RuneScanner, tubes ...RuneScannerTube) (out <-chan io.RuneScanner)
func SectionReaderDaisy(inp <-chan *io.SectionReader, tube SectionReaderTube) (out <-chan *io.SectionReader)
func SectionReaderDaisyChain(inp <-chan *io.SectionReader, tubes ...SectionReaderTube) (out <-chan *io.SectionReader)
func SeekerDaisy(inp <-chan io.Seeker, tube SeekerTube) (out <-chan io.Seeker)
func SeekerDaisyChain(inp <-chan io.Seeker, tubes ...SeekerTube) (out <-chan io.Seeker)
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 SendProxyCloser(out chan<- io.Closer) chan<- io.Closer
func SendProxyLimitedReader(out chan<- *io.LimitedReader) chan<- *io.LimitedReader
func SendProxyPipeReader(out chan<- *io.PipeReader) chan<- *io.PipeReader
func SendProxyPipeWriter(out chan<- *io.PipeWriter) chan<- *io.PipeWriter
func SendProxyReadCloser(out chan<- io.ReadCloser) chan<- io.ReadCloser
func SendProxyReadSeeker(out chan<- io.ReadSeeker) chan<- io.ReadSeeker
func SendProxyReadWriteCloser(out chan<- io.ReadWriteCloser) chan<- io.ReadWriteCloser
func SendProxyReadWriteSeeker(out chan<- io.ReadWriteSeeker) chan<- io.ReadWriteSeeker
func SendProxyReadWriter(out chan<- io.ReadWriter) chan<- io.ReadWriter
func SendProxyReader(out chan<- io.Reader) chan<- io.Reader
func SendProxyReaderAt(out chan<- io.ReaderAt) chan<- io.ReaderAt
func SendProxyReaderFrom(out chan<- io.ReaderFrom) chan<- io.ReaderFrom
func SendProxyRuneReader(out chan<- io.RuneReader) chan<- io.RuneReader
func SendProxyRuneScanner(out chan<- io.RuneScanner) chan<- io.RuneScanner
func SendProxySectionReader(out chan<- *io.SectionReader) chan<- *io.SectionReader
func SendProxySeeker(out chan<- io.Seeker) chan<- io.Seeker
func SendProxyWriteCloser(out chan<- io.WriteCloser) chan<- io.WriteCloser
func SendProxyWriteSeeker(out chan<- io.WriteSeeker) chan<- io.WriteSeeker
func SendProxyWriter(out chan<- io.Writer) chan<- io.Writer
func SendProxyWriterAt(out chan<- io.WriterAt) chan<- io.WriterAt
func SendProxyWriterTo(out chan<- io.WriterTo) chan<- io.WriterTo
func WriteCloserDaisy(inp <-chan io.WriteCloser, tube WriteCloserTube) (out <-chan io.WriteCloser)
func WriteCloserDaisyChain(inp <-chan io.WriteCloser, tubes ...WriteCloserTube) (out <-chan io.WriteCloser)
func WriteSeekerDaisy(inp <-chan io.WriteSeeker, tube WriteSeekerTube) (out <-chan io.WriteSeeker)
func WriteSeekerDaisyChain(inp <-chan io.WriteSeeker, tubes ...WriteSeekerTube) (out <-chan io.WriteSeeker)
func WriterAtDaisy(inp <-chan io.WriterAt, tube WriterAtTube) (out <-chan io.WriterAt)
func WriterAtDaisyChain(inp <-chan io.WriterAt, tubes ...WriterAtTube) (out <-chan io.WriterAt)
func WriterDaisy(inp <-chan io.Writer, tube WriterTube) (out <-chan io.Writer)
func WriterDaisyChain(inp <-chan io.Writer, tubes ...WriterTube) (out <-chan io.Writer)
func WriterToDaisy(inp <-chan io.WriterTo, tube WriterToTube) (out <-chan io.WriterTo)
func WriterToDaisyChain(inp <-chan io.WriterTo, tubes ...WriterToTube) (out <-chan io.WriterTo)
type ByteReaderTube
type ByteScannerTube
type ByteWriterTube
type CloserTube
type LimitedReaderTube
type PipeReaderTube
type PipeWriterTube
type ReadCloserTube
type ReadSeekerTube
type ReadWriteCloserTube
type ReadWriteSeekerTube
type ReadWriterTube
type ReaderAtTube
type ReaderFromTube
type ReaderTube
type RuneReaderTube
type RuneScannerTube
type SectionReaderTube
type SeekerTube
type WriteCloserTube
type WriteSeekerTube
type WriterAtTube
type WriterToTube
type WriterTube

Constants ¶

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 CloserCAP = 10

CloserCAP is the capacity of the buffered proxy channel

View Source

const CloserQUE = 16

CloserQUE is the allocated size of the circular queue

View Source

const LimitedReaderCAP = 10

LimitedReaderCAP is the capacity of the buffered proxy channel

View Source

const LimitedReaderQUE = 16

LimitedReaderQUE is the allocated size of the circular queue

View Source

const PipeReaderCAP = 10

PipeReaderCAP is the capacity of the buffered proxy channel

View Source

const PipeReaderQUE = 16

PipeReaderQUE is the allocated size of the circular queue

View Source

const PipeWriterCAP = 10

PipeWriterCAP is the capacity of the buffered proxy channel

View Source

const PipeWriterQUE = 16

PipeWriterQUE is the allocated size of the circular queue

View Source

const ReadCloserCAP = 10

ReadCloserCAP is the capacity of the buffered proxy channel

View Source

const ReadCloserQUE = 16

ReadCloserQUE is the allocated size of the circular queue

View Source

const ReadSeekerCAP = 10

ReadSeekerCAP is the capacity of the buffered proxy channel

View Source

const ReadSeekerQUE = 16

ReadSeekerQUE is the allocated size of the circular queue

View Source

const ReadWriteCloserCAP = 10

ReadWriteCloserCAP is the capacity of the buffered proxy channel

View Source

const ReadWriteCloserQUE = 16

ReadWriteCloserQUE is the allocated size of the circular queue

View Source

const ReadWriteSeekerCAP = 10

ReadWriteSeekerCAP is the capacity of the buffered proxy channel

View Source

const ReadWriteSeekerQUE = 16

ReadWriteSeekerQUE is the allocated size of the circular queue

View Source

const ReadWriterCAP = 10

ReadWriterCAP is the capacity of the buffered proxy channel

View Source

const ReadWriterQUE = 16

ReadWriterQUE is the allocated size of the circular queue

View Source

const ReaderAtCAP = 10

ReaderAtCAP is the capacity of the buffered proxy channel

View Source

const ReaderAtQUE = 16

ReaderAtQUE 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 ReaderFromCAP = 10

ReaderFromCAP is the capacity of the buffered proxy channel

View Source

const ReaderFromQUE = 16

ReaderFromQUE is the allocated size of the circular queue

View Source

const ReaderQUE = 16

ReaderQUE is the allocated size of the circular queue

View Source

const RuneReaderCAP = 10

RuneReaderCAP is the capacity of the buffered proxy channel

View Source

const RuneReaderQUE = 16

RuneReaderQUE is the allocated size of the circular queue

View Source

const RuneScannerCAP = 10

RuneScannerCAP is the capacity of the buffered proxy channel

View Source

const RuneScannerQUE = 16

RuneScannerQUE is the allocated size of the circular queue

View Source

const SectionReaderCAP = 10

SectionReaderCAP is the capacity of the buffered proxy channel

View Source

const SectionReaderQUE = 16

SectionReaderQUE is the allocated size of the circular queue

View Source

const SeekerCAP = 10

SeekerCAP is the capacity of the buffered proxy channel

View Source

const SeekerQUE = 16

SeekerQUE is the allocated size of the circular queue

View Source

const WriteCloserCAP = 10

WriteCloserCAP is the capacity of the buffered proxy channel

View Source

const WriteCloserQUE = 16

WriteCloserQUE is the allocated size of the circular queue

View Source

const WriteSeekerCAP = 10

WriteSeekerCAP is the capacity of the buffered proxy channel

View Source

const WriteSeekerQUE = 16

WriteSeekerQUE is the allocated size of the circular queue

View Source

const WriterAtCAP = 10

WriterAtCAP is the capacity of the buffered proxy channel

View Source

const WriterAtQUE = 16

WriterAtQUE is the allocated size of the circular queue

View Source

const WriterCAP = 10

WriterCAP is the capacity of the buffered proxy channel

View Source

const WriterQUE = 16

WriterQUE is the allocated size of the circular queue

View Source

const WriterToCAP = 10

WriterToCAP is the capacity of the buffered proxy channel

View Source

const WriterToQUE = 16

WriterToQUE is the allocated size of the circular queue

Variables ¶

This section is empty.

Functions ¶

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 ChanByteReader ¶

func ChanByteReader(inp ...io.ByteReader) (out <-chan io.ByteReader)

ChanByteReader returns a channel to receive all inputs before close.

func ChanByteReaderFuncErr ¶

func ChanByteReaderFuncErr(act func() (io.ByteReader, error)) (out <-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)) (out <-chan io.ByteReader)

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

func ChanByteReaderSlice ¶

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

ChanByteReaderSlice returns a channel to receive all inputs before close.

func ChanByteScanner ¶

func ChanByteScanner(inp ...io.ByteScanner) (out <-chan io.ByteScanner)

ChanByteScanner returns a channel to receive all inputs before close.

func ChanByteScannerFuncErr ¶

func ChanByteScannerFuncErr(act func() (io.ByteScanner, error)) (out <-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)) (out <-chan io.ByteScanner)

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

func ChanByteScannerSlice ¶

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

ChanByteScannerSlice returns a channel to receive all inputs before close.

func ChanByteWriter ¶

func ChanByteWriter(inp ...io.ByteWriter) (out <-chan io.ByteWriter)

ChanByteWriter returns a channel to receive all inputs before close.

func ChanByteWriterFuncErr ¶

func ChanByteWriterFuncErr(act func() (io.ByteWriter, error)) (out <-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)) (out <-chan io.ByteWriter)

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

func ChanByteWriterSlice ¶

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

ChanByteWriterSlice returns a channel to receive all inputs before close.

func ChanCloser ¶

func ChanCloser(inp ...io.Closer) (out <-chan io.Closer)

ChanCloser returns a channel to receive all inputs before close.

func ChanCloserFuncErr ¶

func ChanCloserFuncErr(act func() (io.Closer, error)) (out <-chan io.Closer)

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

func ChanCloserFuncNok ¶

func ChanCloserFuncNok(act func() (io.Closer, bool)) (out <-chan io.Closer)

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

func ChanCloserSlice ¶

func ChanCloserSlice(inp ...[]io.Closer) (out <-chan io.Closer)

ChanCloserSlice returns a channel to receive all inputs before close.

func ChanLimitedReader ¶

func ChanLimitedReader(inp ...*io.LimitedReader) (out <-chan *io.LimitedReader)

ChanLimitedReader returns a channel to receive all inputs before close.

func ChanLimitedReaderFuncErr ¶

func ChanLimitedReaderFuncErr(act func() (*io.LimitedReader, error)) (out <-chan *io.LimitedReader)

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

func ChanLimitedReaderFuncNok ¶

func ChanLimitedReaderFuncNok(act func() (*io.LimitedReader, bool)) (out <-chan *io.LimitedReader)

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

func ChanLimitedReaderSlice ¶

func ChanLimitedReaderSlice(inp ...[]*io.LimitedReader) (out <-chan *io.LimitedReader)

ChanLimitedReaderSlice returns a channel to receive all inputs before close.

func ChanPipeReader ¶

func ChanPipeReader(inp ...*io.PipeReader) (out <-chan *io.PipeReader)

ChanPipeReader returns a channel to receive all inputs before close.

func ChanPipeReaderFuncErr ¶

func ChanPipeReaderFuncErr(act func() (*io.PipeReader, error)) (out <-chan *io.PipeReader)

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

func ChanPipeReaderFuncNok ¶

func ChanPipeReaderFuncNok(act func() (*io.PipeReader, bool)) (out <-chan *io.PipeReader)

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

func ChanPipeReaderSlice ¶

func ChanPipeReaderSlice(inp ...[]*io.PipeReader) (out <-chan *io.PipeReader)

ChanPipeReaderSlice returns a channel to receive all inputs before close.

func ChanPipeWriter ¶

func ChanPipeWriter(inp ...*io.PipeWriter) (out <-chan *io.PipeWriter)

ChanPipeWriter returns a channel to receive all inputs before close.

func ChanPipeWriterFuncErr ¶

func ChanPipeWriterFuncErr(act func() (*io.PipeWriter, error)) (out <-chan *io.PipeWriter)

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

func ChanPipeWriterFuncNok ¶

func ChanPipeWriterFuncNok(act func() (*io.PipeWriter, bool)) (out <-chan *io.PipeWriter)

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

func ChanPipeWriterSlice ¶

func ChanPipeWriterSlice(inp ...[]*io.PipeWriter) (out <-chan *io.PipeWriter)

ChanPipeWriterSlice returns a channel to receive all inputs before close.

func ChanReadCloser ¶

func ChanReadCloser(inp ...io.ReadCloser) (out <-chan io.ReadCloser)

ChanReadCloser returns a channel to receive all inputs before close.

func ChanReadCloserFuncErr ¶

func ChanReadCloserFuncErr(act func() (io.ReadCloser, error)) (out <-chan io.ReadCloser)

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

func ChanReadCloserFuncNok ¶

func ChanReadCloserFuncNok(act func() (io.ReadCloser, bool)) (out <-chan io.ReadCloser)

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

func ChanReadCloserSlice ¶

func ChanReadCloserSlice(inp ...[]io.ReadCloser) (out <-chan io.ReadCloser)

ChanReadCloserSlice returns a channel to receive all inputs before close.

func ChanReadSeeker ¶

func ChanReadSeeker(inp ...io.ReadSeeker) (out <-chan io.ReadSeeker)

ChanReadSeeker returns a channel to receive all inputs before close.

func ChanReadSeekerFuncErr ¶

func ChanReadSeekerFuncErr(act func() (io.ReadSeeker, error)) (out <-chan io.ReadSeeker)

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

func ChanReadSeekerFuncNok ¶

func ChanReadSeekerFuncNok(act func() (io.ReadSeeker, bool)) (out <-chan io.ReadSeeker)

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

func ChanReadSeekerSlice ¶

func ChanReadSeekerSlice(inp ...[]io.ReadSeeker) (out <-chan io.ReadSeeker)

ChanReadSeekerSlice returns a channel to receive all inputs before close.

func ChanReadWriteCloser ¶

func ChanReadWriteCloser(inp ...io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)

ChanReadWriteCloser returns a channel to receive all inputs before close.

func ChanReadWriteCloserFuncErr ¶

func ChanReadWriteCloserFuncErr(act func() (io.ReadWriteCloser, error)) (out <-chan io.ReadWriteCloser)

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

func ChanReadWriteCloserFuncNok ¶

func ChanReadWriteCloserFuncNok(act func() (io.ReadWriteCloser, bool)) (out <-chan io.ReadWriteCloser)

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

func ChanReadWriteCloserSlice ¶

func ChanReadWriteCloserSlice(inp ...[]io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)

ChanReadWriteCloserSlice returns a channel to receive all inputs before close.

func ChanReadWriteSeeker ¶

func ChanReadWriteSeeker(inp ...io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)

ChanReadWriteSeeker returns a channel to receive all inputs before close.

func ChanReadWriteSeekerFuncErr ¶

func ChanReadWriteSeekerFuncErr(act func() (io.ReadWriteSeeker, error)) (out <-chan io.ReadWriteSeeker)

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

func ChanReadWriteSeekerFuncNok ¶

func ChanReadWriteSeekerFuncNok(act func() (io.ReadWriteSeeker, bool)) (out <-chan io.ReadWriteSeeker)

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

func ChanReadWriteSeekerSlice ¶

func ChanReadWriteSeekerSlice(inp ...[]io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)

ChanReadWriteSeekerSlice returns a channel to receive all inputs before close.

func ChanReadWriter ¶

func ChanReadWriter(inp ...io.ReadWriter) (out <-chan io.ReadWriter)

ChanReadWriter returns a channel to receive all inputs before close.

func ChanReadWriterFuncErr ¶

func ChanReadWriterFuncErr(act func() (io.ReadWriter, error)) (out <-chan io.ReadWriter)

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

func ChanReadWriterFuncNok ¶

func ChanReadWriterFuncNok(act func() (io.ReadWriter, bool)) (out <-chan io.ReadWriter)

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

func ChanReadWriterSlice ¶

func ChanReadWriterSlice(inp ...[]io.ReadWriter) (out <-chan io.ReadWriter)

ChanReadWriterSlice returns a channel to receive all inputs before close.

func ChanReader ¶

func ChanReader(inp ...io.Reader) (out <-chan io.Reader)

ChanReader returns a channel to receive all inputs before close.

func ChanReaderAt ¶

func ChanReaderAt(inp ...io.ReaderAt) (out <-chan io.ReaderAt)

ChanReaderAt returns a channel to receive all inputs before close.

func ChanReaderAtFuncErr ¶

func ChanReaderAtFuncErr(act func() (io.ReaderAt, error)) (out <-chan io.ReaderAt)

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

func ChanReaderAtFuncNok ¶

func ChanReaderAtFuncNok(act func() (io.ReaderAt, bool)) (out <-chan io.ReaderAt)

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

func ChanReaderAtSlice ¶

func ChanReaderAtSlice(inp ...[]io.ReaderAt) (out <-chan io.ReaderAt)

ChanReaderAtSlice returns a channel to receive all inputs before close.

func ChanReaderFrom ¶

func ChanReaderFrom(inp ...io.ReaderFrom) (out <-chan io.ReaderFrom)

ChanReaderFrom returns a channel to receive all inputs before close.

func ChanReaderFromFuncErr ¶

func ChanReaderFromFuncErr(act func() (io.ReaderFrom, error)) (out <-chan io.ReaderFrom)

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

func ChanReaderFromFuncNok ¶

func ChanReaderFromFuncNok(act func() (io.ReaderFrom, bool)) (out <-chan io.ReaderFrom)

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

func ChanReaderFromSlice ¶

func ChanReaderFromSlice(inp ...[]io.ReaderFrom) (out <-chan io.ReaderFrom)

ChanReaderFromSlice returns a channel to receive all inputs before close.

func ChanReaderFuncErr ¶

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

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

func ChanReaderFuncNok ¶

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

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

func ChanReaderSlice ¶

func ChanReaderSlice(inp ...[]io.Reader) (out <-chan io.Reader)

ChanReaderSlice returns a channel to receive all inputs before close.

func ChanRuneReader ¶

func ChanRuneReader(inp ...io.RuneReader) (out <-chan io.RuneReader)

ChanRuneReader returns a channel to receive all inputs before close.

func ChanRuneReaderFuncErr ¶

func ChanRuneReaderFuncErr(act func() (io.RuneReader, error)) (out <-chan io.RuneReader)

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

func ChanRuneReaderFuncNok ¶

func ChanRuneReaderFuncNok(act func() (io.RuneReader, bool)) (out <-chan io.RuneReader)

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

func ChanRuneReaderSlice ¶

func ChanRuneReaderSlice(inp ...[]io.RuneReader) (out <-chan io.RuneReader)

ChanRuneReaderSlice returns a channel to receive all inputs before close.

func ChanRuneScanner ¶

func ChanRuneScanner(inp ...io.RuneScanner) (out <-chan io.RuneScanner)

ChanRuneScanner returns a channel to receive all inputs before close.

func ChanRuneScannerFuncErr ¶

func ChanRuneScannerFuncErr(act func() (io.RuneScanner, error)) (out <-chan io.RuneScanner)

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

func ChanRuneScannerFuncNok ¶

func ChanRuneScannerFuncNok(act func() (io.RuneScanner, bool)) (out <-chan io.RuneScanner)

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

func ChanRuneScannerSlice ¶

func ChanRuneScannerSlice(inp ...[]io.RuneScanner) (out <-chan io.RuneScanner)

ChanRuneScannerSlice returns a channel to receive all inputs before close.

func ChanSectionReader ¶

func ChanSectionReader(inp ...*io.SectionReader) (out <-chan *io.SectionReader)

ChanSectionReader returns a channel to receive all inputs before close.

func ChanSectionReaderFuncErr ¶

func ChanSectionReaderFuncErr(act func() (*io.SectionReader, error)) (out <-chan *io.SectionReader)

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

func ChanSectionReaderFuncNok ¶

func ChanSectionReaderFuncNok(act func() (*io.SectionReader, bool)) (out <-chan *io.SectionReader)

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

func ChanSectionReaderSlice ¶

func ChanSectionReaderSlice(inp ...[]*io.SectionReader) (out <-chan *io.SectionReader)

ChanSectionReaderSlice returns a channel to receive all inputs before close.

func ChanSeeker ¶

func ChanSeeker(inp ...io.Seeker) (out <-chan io.Seeker)

ChanSeeker returns a channel to receive all inputs before close.

func ChanSeekerFuncErr ¶

func ChanSeekerFuncErr(act func() (io.Seeker, error)) (out <-chan io.Seeker)

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

func ChanSeekerFuncNok ¶

func ChanSeekerFuncNok(act func() (io.Seeker, bool)) (out <-chan io.Seeker)

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

func ChanSeekerSlice ¶

func ChanSeekerSlice(inp ...[]io.Seeker) (out <-chan io.Seeker)

ChanSeekerSlice returns a channel to receive all inputs before close.

func ChanWriteCloser ¶

func ChanWriteCloser(inp ...io.WriteCloser) (out <-chan io.WriteCloser)

ChanWriteCloser returns a channel to receive all inputs before close.

func ChanWriteCloserFuncErr ¶

func ChanWriteCloserFuncErr(act func() (io.WriteCloser, error)) (out <-chan io.WriteCloser)

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

func ChanWriteCloserFuncNok ¶

func ChanWriteCloserFuncNok(act func() (io.WriteCloser, bool)) (out <-chan io.WriteCloser)

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

func ChanWriteCloserSlice ¶

func ChanWriteCloserSlice(inp ...[]io.WriteCloser) (out <-chan io.WriteCloser)

ChanWriteCloserSlice returns a channel to receive all inputs before close.

func ChanWriteSeeker ¶

func ChanWriteSeeker(inp ...io.WriteSeeker) (out <-chan io.WriteSeeker)

ChanWriteSeeker returns a channel to receive all inputs before close.

func ChanWriteSeekerFuncErr ¶

func ChanWriteSeekerFuncErr(act func() (io.WriteSeeker, error)) (out <-chan io.WriteSeeker)

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

func ChanWriteSeekerFuncNok ¶

func ChanWriteSeekerFuncNok(act func() (io.WriteSeeker, bool)) (out <-chan io.WriteSeeker)

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

func ChanWriteSeekerSlice ¶

func ChanWriteSeekerSlice(inp ...[]io.WriteSeeker) (out <-chan io.WriteSeeker)

ChanWriteSeekerSlice returns a channel to receive all inputs before close.

func ChanWriter ¶

func ChanWriter(inp ...io.Writer) (out <-chan io.Writer)

ChanWriter returns a channel to receive all inputs before close.

func ChanWriterAt ¶

func ChanWriterAt(inp ...io.WriterAt) (out <-chan io.WriterAt)

ChanWriterAt returns a channel to receive all inputs before close.

func ChanWriterAtFuncErr ¶

func ChanWriterAtFuncErr(act func() (io.WriterAt, error)) (out <-chan io.WriterAt)

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

func ChanWriterAtFuncNok ¶

func ChanWriterAtFuncNok(act func() (io.WriterAt, bool)) (out <-chan io.WriterAt)

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

func ChanWriterAtSlice ¶

func ChanWriterAtSlice(inp ...[]io.WriterAt) (out <-chan io.WriterAt)

ChanWriterAtSlice returns a channel to receive all inputs before close.

func ChanWriterFuncErr ¶

func ChanWriterFuncErr(act func() (io.Writer, error)) (out <-chan io.Writer)

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

func ChanWriterFuncNok ¶

func ChanWriterFuncNok(act func() (io.Writer, bool)) (out <-chan io.Writer)

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

func ChanWriterSlice ¶

func ChanWriterSlice(inp ...[]io.Writer) (out <-chan io.Writer)

ChanWriterSlice returns a channel to receive all inputs before close.

func ChanWriterTo ¶

func ChanWriterTo(inp ...io.WriterTo) (out <-chan io.WriterTo)

ChanWriterTo returns a channel to receive all inputs before close.

func ChanWriterToFuncErr ¶

func ChanWriterToFuncErr(act func() (io.WriterTo, error)) (out <-chan io.WriterTo)

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

func ChanWriterToFuncNok ¶

func ChanWriterToFuncNok(act func() (io.WriterTo, bool)) (out <-chan io.WriterTo)

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

func ChanWriterToSlice ¶

func ChanWriterToSlice(inp ...[]io.WriterTo) (out <-chan io.WriterTo)

ChanWriterToSlice returns a channel to receive all inputs before close.

func CloserDaisy ¶

func CloserDaisy(inp <-chan io.Closer, tube CloserTube) (out <-chan io.Closer)

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

func CloserDaisyChain ¶

func CloserDaisyChain(inp <-chan io.Closer, tubes ...CloserTube) (out <-chan io.Closer)

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

func DoneByteReader ¶

func DoneByteReader(inp <-chan io.ByteReader) (done <-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)) (out <-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) (done <-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) (done <-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)) (out <-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) (done <-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 DoneByteWriter ¶

func DoneByteWriter(inp <-chan io.ByteWriter) (done <-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)) (out <-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) (done <-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 DoneCloser ¶

func DoneCloser(inp <-chan io.Closer) (done <-chan struct{})

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

func DoneCloserFunc ¶

func DoneCloserFunc(inp <-chan io.Closer, act func(a io.Closer)) (out <-chan struct{})

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

func DoneCloserSlice ¶

func DoneCloserSlice(inp <-chan io.Closer) (done <-chan ([]io.Closer))

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

func DoneLimitedReader ¶

func DoneLimitedReader(inp <-chan *io.LimitedReader) (done <-chan struct{})

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

func DoneLimitedReaderFunc ¶

func DoneLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader)) (out <-chan struct{})

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

func DoneLimitedReaderSlice ¶

func DoneLimitedReaderSlice(inp <-chan *io.LimitedReader) (done <-chan ([]*io.LimitedReader))

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

func DonePipeReader ¶

func DonePipeReader(inp <-chan *io.PipeReader) (done <-chan struct{})

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

func DonePipeReaderFunc ¶

func DonePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader)) (out <-chan struct{})

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

func DonePipeReaderSlice ¶

func DonePipeReaderSlice(inp <-chan *io.PipeReader) (done <-chan ([]*io.PipeReader))

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

func DonePipeWriter ¶

func DonePipeWriter(inp <-chan *io.PipeWriter) (done <-chan struct{})

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

func DonePipeWriterFunc ¶

func DonePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter)) (out <-chan struct{})

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

func DonePipeWriterSlice ¶

func DonePipeWriterSlice(inp <-chan *io.PipeWriter) (done <-chan ([]*io.PipeWriter))

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

func DoneReadCloser ¶

func DoneReadCloser(inp <-chan io.ReadCloser) (done <-chan struct{})

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

func DoneReadCloserFunc ¶

func DoneReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser)) (out <-chan struct{})

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

func DoneReadCloserSlice ¶

func DoneReadCloserSlice(inp <-chan io.ReadCloser) (done <-chan ([]io.ReadCloser))

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

func DoneReadSeeker ¶

func DoneReadSeeker(inp <-chan io.ReadSeeker) (done <-chan struct{})

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

func DoneReadSeekerFunc ¶

func DoneReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker)) (out <-chan struct{})

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

func DoneReadSeekerSlice ¶

func DoneReadSeekerSlice(inp <-chan io.ReadSeeker) (done <-chan ([]io.ReadSeeker))

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

func DoneReadWriteCloser ¶

func DoneReadWriteCloser(inp <-chan io.ReadWriteCloser) (done <-chan struct{})

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

func DoneReadWriteCloserFunc ¶

func DoneReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, act func(a io.ReadWriteCloser)) (out <-chan struct{})

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

func DoneReadWriteCloserSlice ¶

func DoneReadWriteCloserSlice(inp <-chan io.ReadWriteCloser) (done <-chan ([]io.ReadWriteCloser))

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

func DoneReadWriteSeeker ¶

func DoneReadWriteSeeker(inp <-chan io.ReadWriteSeeker) (done <-chan struct{})

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

func DoneReadWriteSeekerFunc ¶

func DoneReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, act func(a io.ReadWriteSeeker)) (out <-chan struct{})

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

func DoneReadWriteSeekerSlice ¶

func DoneReadWriteSeekerSlice(inp <-chan io.ReadWriteSeeker) (done <-chan ([]io.ReadWriteSeeker))

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

func DoneReadWriter ¶

func DoneReadWriter(inp <-chan io.ReadWriter) (done <-chan struct{})

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

func DoneReadWriterFunc ¶

func DoneReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter)) (out <-chan struct{})

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

func DoneReadWriterSlice ¶

func DoneReadWriterSlice(inp <-chan io.ReadWriter) (done <-chan ([]io.ReadWriter))

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

func DoneReader ¶

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

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

func DoneReaderAt ¶

func DoneReaderAt(inp <-chan io.ReaderAt) (done <-chan struct{})

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

func DoneReaderAtFunc ¶

func DoneReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt)) (out <-chan struct{})

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

func DoneReaderAtSlice ¶

func DoneReaderAtSlice(inp <-chan io.ReaderAt) (done <-chan ([]io.ReaderAt))

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

func DoneReaderFrom ¶

func DoneReaderFrom(inp <-chan io.ReaderFrom) (done <-chan struct{})

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

func DoneReaderFromFunc ¶

func DoneReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom)) (out <-chan struct{})

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

func DoneReaderFromSlice ¶

func DoneReaderFromSlice(inp <-chan io.ReaderFrom) (done <-chan ([]io.ReaderFrom))

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

func DoneReaderFunc ¶

func DoneReaderFunc(inp <-chan io.Reader, act func(a io.Reader)) (out <-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 io.Reader) (done <-chan ([]io.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 DoneRuneReader ¶

func DoneRuneReader(inp <-chan io.RuneReader) (done <-chan struct{})

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

func DoneRuneReaderFunc ¶

func DoneRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader)) (out <-chan struct{})

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

func DoneRuneReaderSlice ¶

func DoneRuneReaderSlice(inp <-chan io.RuneReader) (done <-chan ([]io.RuneReader))

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

func DoneRuneScanner ¶

func DoneRuneScanner(inp <-chan io.RuneScanner) (done <-chan struct{})

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

func DoneRuneScannerFunc ¶

func DoneRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner)) (out <-chan struct{})

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

func DoneRuneScannerSlice ¶

func DoneRuneScannerSlice(inp <-chan io.RuneScanner) (done <-chan ([]io.RuneScanner))

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

func DoneSectionReader ¶

func DoneSectionReader(inp <-chan *io.SectionReader) (done <-chan struct{})

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

func DoneSectionReaderFunc ¶

func DoneSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader)) (out <-chan struct{})

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

func DoneSectionReaderSlice ¶

func DoneSectionReaderSlice(inp <-chan *io.SectionReader) (done <-chan ([]*io.SectionReader))

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

func DoneSeeker ¶

func DoneSeeker(inp <-chan io.Seeker) (done <-chan struct{})

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

func DoneSeekerFunc ¶

func DoneSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker)) (out <-chan struct{})

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

func DoneSeekerSlice ¶

func DoneSeekerSlice(inp <-chan io.Seeker) (done <-chan ([]io.Seeker))

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

func DoneWriteCloser ¶

func DoneWriteCloser(inp <-chan io.WriteCloser) (done <-chan struct{})

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

func DoneWriteCloserFunc ¶

func DoneWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser)) (out <-chan struct{})

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

func DoneWriteCloserSlice ¶

func DoneWriteCloserSlice(inp <-chan io.WriteCloser) (done <-chan ([]io.WriteCloser))

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

func DoneWriteSeeker ¶

func DoneWriteSeeker(inp <-chan io.WriteSeeker) (done <-chan struct{})

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

func DoneWriteSeekerFunc ¶

func DoneWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker)) (out <-chan struct{})

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

func DoneWriteSeekerSlice ¶

func DoneWriteSeekerSlice(inp <-chan io.WriteSeeker) (done <-chan ([]io.WriteSeeker))

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

func DoneWriter ¶

func DoneWriter(inp <-chan io.Writer) (done <-chan struct{})

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

func DoneWriterAt ¶

func DoneWriterAt(inp <-chan io.WriterAt) (done <-chan struct{})

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

func DoneWriterAtFunc ¶

func DoneWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt)) (out <-chan struct{})

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

func DoneWriterAtSlice ¶

func DoneWriterAtSlice(inp <-chan io.WriterAt) (done <-chan ([]io.WriterAt))

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

func DoneWriterFunc ¶

func DoneWriterFunc(inp <-chan io.Writer, act func(a io.Writer)) (out <-chan struct{})

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

func DoneWriterSlice ¶

func DoneWriterSlice(inp <-chan io.Writer) (done <-chan ([]io.Writer))

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

func DoneWriterTo ¶

func DoneWriterTo(inp <-chan io.WriterTo) (done <-chan struct{})

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

func DoneWriterToFunc ¶

func DoneWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo)) (out <-chan struct{})

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

func DoneWriterToSlice ¶

func DoneWriterToSlice(inp <-chan io.WriterTo) (done <-chan ([]io.WriterTo))

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

func JoinByteReader ¶

func JoinByteReader(out chan<- io.ByteReader, inp ...io.ByteReader) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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) (done <-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 JoinByteWriter ¶

func JoinByteWriter(out chan<- io.ByteWriter, inp ...io.ByteWriter) (done <-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) (done <-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) (done <-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 JoinCloser ¶

func JoinCloser(out chan<- io.Closer, inp ...io.Closer) (done <-chan struct{})

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

func JoinCloserChan ¶

func JoinCloserChan(out chan<- io.Closer, inp <-chan io.Closer) (done <-chan struct{})

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

func JoinCloserSlice ¶

func JoinCloserSlice(out chan<- io.Closer, inp ...[]io.Closer) (done <-chan struct{})

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

func JoinLimitedReader ¶

func JoinLimitedReader(out chan<- *io.LimitedReader, inp ...*io.LimitedReader) (done <-chan struct{})

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

func JoinLimitedReaderChan ¶

func JoinLimitedReaderChan(out chan<- *io.LimitedReader, inp <-chan *io.LimitedReader) (done <-chan struct{})

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

func JoinLimitedReaderSlice ¶

func JoinLimitedReaderSlice(out chan<- *io.LimitedReader, inp ...[]*io.LimitedReader) (done <-chan struct{})

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

func JoinPipeReader ¶

func JoinPipeReader(out chan<- *io.PipeReader, inp ...*io.PipeReader) (done <-chan struct{})

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

func JoinPipeReaderChan ¶

func JoinPipeReaderChan(out chan<- *io.PipeReader, inp <-chan *io.PipeReader) (done <-chan struct{})

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

func JoinPipeReaderSlice ¶

func JoinPipeReaderSlice(out chan<- *io.PipeReader, inp ...[]*io.PipeReader) (done <-chan struct{})

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

func JoinPipeWriter ¶

func JoinPipeWriter(out chan<- *io.PipeWriter, inp ...*io.PipeWriter) (done <-chan struct{})

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

func JoinPipeWriterChan ¶

func JoinPipeWriterChan(out chan<- *io.PipeWriter, inp <-chan *io.PipeWriter) (done <-chan struct{})

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

func JoinPipeWriterSlice ¶

func JoinPipeWriterSlice(out chan<- *io.PipeWriter, inp ...[]*io.PipeWriter) (done <-chan struct{})

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

func JoinReadCloser ¶

func JoinReadCloser(out chan<- io.ReadCloser, inp ...io.ReadCloser) (done <-chan struct{})

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

func JoinReadCloserChan ¶

func JoinReadCloserChan(out chan<- io.ReadCloser, inp <-chan io.ReadCloser) (done <-chan struct{})

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

func JoinReadCloserSlice ¶

func JoinReadCloserSlice(out chan<- io.ReadCloser, inp ...[]io.ReadCloser) (done <-chan struct{})

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

func JoinReadSeeker ¶

func JoinReadSeeker(out chan<- io.ReadSeeker, inp ...io.ReadSeeker) (done <-chan struct{})

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

func JoinReadSeekerChan ¶

func JoinReadSeekerChan(out chan<- io.ReadSeeker, inp <-chan io.ReadSeeker) (done <-chan struct{})

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

func JoinReadSeekerSlice ¶

func JoinReadSeekerSlice(out chan<- io.ReadSeeker, inp ...[]io.ReadSeeker) (done <-chan struct{})

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

func JoinReadWriteCloser ¶

func JoinReadWriteCloser(out chan<- io.ReadWriteCloser, inp ...io.ReadWriteCloser) (done <-chan struct{})

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

func JoinReadWriteCloserChan ¶

func JoinReadWriteCloserChan(out chan<- io.ReadWriteCloser, inp <-chan io.ReadWriteCloser) (done <-chan struct{})

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

func JoinReadWriteCloserSlice ¶

func JoinReadWriteCloserSlice(out chan<- io.ReadWriteCloser, inp ...[]io.ReadWriteCloser) (done <-chan struct{})

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

func JoinReadWriteSeeker ¶

func JoinReadWriteSeeker(out chan<- io.ReadWriteSeeker, inp ...io.ReadWriteSeeker) (done <-chan struct{})

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

func JoinReadWriteSeekerChan ¶

func JoinReadWriteSeekerChan(out chan<- io.ReadWriteSeeker, inp <-chan io.ReadWriteSeeker) (done <-chan struct{})

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

func JoinReadWriteSeekerSlice ¶

func JoinReadWriteSeekerSlice(out chan<- io.ReadWriteSeeker, inp ...[]io.ReadWriteSeeker) (done <-chan struct{})

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

func JoinReadWriter ¶

func JoinReadWriter(out chan<- io.ReadWriter, inp ...io.ReadWriter) (done <-chan struct{})

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

func JoinReadWriterChan ¶

func JoinReadWriterChan(out chan<- io.ReadWriter, inp <-chan io.ReadWriter) (done <-chan struct{})

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

func JoinReadWriterSlice ¶

func JoinReadWriterSlice(out chan<- io.ReadWriter, inp ...[]io.ReadWriter) (done <-chan struct{})

JoinReadWriterSlice 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<- io.Reader, inp ...io.Reader) (done <-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 JoinReaderAt ¶

func JoinReaderAt(out chan<- io.ReaderAt, inp ...io.ReaderAt) (done <-chan struct{})

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

func JoinReaderAtChan ¶

func JoinReaderAtChan(out chan<- io.ReaderAt, inp <-chan io.ReaderAt) (done <-chan struct{})

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

func JoinReaderAtSlice ¶

func JoinReaderAtSlice(out chan<- io.ReaderAt, inp ...[]io.ReaderAt) (done <-chan struct{})

JoinReaderAtSlice 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<- io.Reader, inp <-chan io.Reader) (done <-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 JoinReaderFrom ¶

func JoinReaderFrom(out chan<- io.ReaderFrom, inp ...io.ReaderFrom) (done <-chan struct{})

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

func JoinReaderFromChan ¶

func JoinReaderFromChan(out chan<- io.ReaderFrom, inp <-chan io.ReaderFrom) (done <-chan struct{})

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

func JoinReaderFromSlice ¶

func JoinReaderFromSlice(out chan<- io.ReaderFrom, inp ...[]io.ReaderFrom) (done <-chan struct{})

JoinReaderFromSlice 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<- io.Reader, inp ...[]io.Reader) (done <-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 JoinRuneReader ¶

func JoinRuneReader(out chan<- io.RuneReader, inp ...io.RuneReader) (done <-chan struct{})

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

func JoinRuneReaderChan ¶

func JoinRuneReaderChan(out chan<- io.RuneReader, inp <-chan io.RuneReader) (done <-chan struct{})

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

func JoinRuneReaderSlice ¶

func JoinRuneReaderSlice(out chan<- io.RuneReader, inp ...[]io.RuneReader) (done <-chan struct{})

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

func JoinRuneScanner ¶

func JoinRuneScanner(out chan<- io.RuneScanner, inp ...io.RuneScanner) (done <-chan struct{})

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

func JoinRuneScannerChan ¶

func JoinRuneScannerChan(out chan<- io.RuneScanner, inp <-chan io.RuneScanner) (done <-chan struct{})

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

func JoinRuneScannerSlice ¶

func JoinRuneScannerSlice(out chan<- io.RuneScanner, inp ...[]io.RuneScanner) (done <-chan struct{})

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

func JoinSectionReader ¶

func JoinSectionReader(out chan<- *io.SectionReader, inp ...*io.SectionReader) (done <-chan struct{})

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

func JoinSectionReaderChan ¶

func JoinSectionReaderChan(out chan<- *io.SectionReader, inp <-chan *io.SectionReader) (done <-chan struct{})

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

func JoinSectionReaderSlice ¶

func JoinSectionReaderSlice(out chan<- *io.SectionReader, inp ...[]*io.SectionReader) (done <-chan struct{})

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

func JoinSeeker ¶

func JoinSeeker(out chan<- io.Seeker, inp ...io.Seeker) (done <-chan struct{})

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

func JoinSeekerChan ¶

func JoinSeekerChan(out chan<- io.Seeker, inp <-chan io.Seeker) (done <-chan struct{})

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

func JoinSeekerSlice ¶

func JoinSeekerSlice(out chan<- io.Seeker, inp ...[]io.Seeker) (done <-chan struct{})

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

func JoinWriteCloser ¶

func JoinWriteCloser(out chan<- io.WriteCloser, inp ...io.WriteCloser) (done <-chan struct{})

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

func JoinWriteCloserChan ¶

func JoinWriteCloserChan(out chan<- io.WriteCloser, inp <-chan io.WriteCloser) (done <-chan struct{})

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

func JoinWriteCloserSlice ¶

func JoinWriteCloserSlice(out chan<- io.WriteCloser, inp ...[]io.WriteCloser) (done <-chan struct{})

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

func JoinWriteSeeker ¶

func JoinWriteSeeker(out chan<- io.WriteSeeker, inp ...io.WriteSeeker) (done <-chan struct{})

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

func JoinWriteSeekerChan ¶

func JoinWriteSeekerChan(out chan<- io.WriteSeeker, inp <-chan io.WriteSeeker) (done <-chan struct{})

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

func JoinWriteSeekerSlice ¶

func JoinWriteSeekerSlice(out chan<- io.WriteSeeker, inp ...[]io.WriteSeeker) (done <-chan struct{})

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

func JoinWriter ¶

func JoinWriter(out chan<- io.Writer, inp ...io.Writer) (done <-chan struct{})

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

func JoinWriterAt ¶

func JoinWriterAt(out chan<- io.WriterAt, inp ...io.WriterAt) (done <-chan struct{})

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

func JoinWriterAtChan ¶

func JoinWriterAtChan(out chan<- io.WriterAt, inp <-chan io.WriterAt) (done <-chan struct{})

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

func JoinWriterAtSlice ¶

func JoinWriterAtSlice(out chan<- io.WriterAt, inp ...[]io.WriterAt) (done <-chan struct{})

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

func JoinWriterChan ¶

func JoinWriterChan(out chan<- io.Writer, inp <-chan io.Writer) (done <-chan struct{})

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

func JoinWriterSlice ¶

func JoinWriterSlice(out chan<- io.Writer, inp ...[]io.Writer) (done <-chan struct{})

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

func JoinWriterTo ¶

func JoinWriterTo(out chan<- io.WriterTo, inp ...io.WriterTo) (done <-chan struct{})

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

func JoinWriterToChan ¶

func JoinWriterToChan(out chan<- io.WriterTo, inp <-chan io.WriterTo) (done <-chan struct{})

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

func JoinWriterToSlice ¶

func JoinWriterToSlice(out chan<- io.WriterTo, inp ...[]io.WriterTo) (done <-chan struct{})

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

func LimitedReaderDaisy ¶

func LimitedReaderDaisy(inp <-chan *io.LimitedReader, tube LimitedReaderTube) (out <-chan *io.LimitedReader)

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

func LimitedReaderDaisyChain ¶

func LimitedReaderDaisyChain(inp <-chan *io.LimitedReader, tubes ...LimitedReaderTube) (out <-chan *io.LimitedReader)

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

func MakeByteReaderChan ¶

func MakeByteReaderChan() (out 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() (out 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() (out 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 MakeCloserChan ¶

func MakeCloserChan() (out chan io.Closer)

MakeCloserChan returns a new open channel (simply a 'chan io.Closer' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeCloserBuffer) the channel is unbuffered.

func MakeLimitedReaderChan ¶

func MakeLimitedReaderChan() (out chan *io.LimitedReader)

MakeLimitedReaderChan returns a new open channel (simply a 'chan *io.LimitedReader' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeLimitedReaderBuffer) the channel is unbuffered.

func MakePipeReaderChan ¶

func MakePipeReaderChan() (out chan *io.PipeReader)

MakePipeReaderChan returns a new open channel (simply a 'chan *io.PipeReader' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipePipeReaderBuffer) the channel is unbuffered.

func MakePipeWriterChan ¶

func MakePipeWriterChan() (out chan *io.PipeWriter)

MakePipeWriterChan returns a new open channel (simply a 'chan *io.PipeWriter' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipePipeWriterBuffer) the channel is unbuffered.

func MakeReadCloserChan ¶

func MakeReadCloserChan() (out chan io.ReadCloser)

MakeReadCloserChan returns a new open channel (simply a 'chan io.ReadCloser' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReadCloserBuffer) the channel is unbuffered.

func MakeReadSeekerChan ¶

func MakeReadSeekerChan() (out chan io.ReadSeeker)

MakeReadSeekerChan returns a new open channel (simply a 'chan io.ReadSeeker' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReadSeekerBuffer) the channel is unbuffered.

func MakeReadWriteCloserChan ¶

func MakeReadWriteCloserChan() (out chan io.ReadWriteCloser)

MakeReadWriteCloserChan returns a new open channel (simply a 'chan io.ReadWriteCloser' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReadWriteCloserBuffer) the channel is unbuffered.

func MakeReadWriteSeekerChan ¶

func MakeReadWriteSeekerChan() (out chan io.ReadWriteSeeker)

MakeReadWriteSeekerChan returns a new open channel (simply a 'chan io.ReadWriteSeeker' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReadWriteSeekerBuffer) the channel is unbuffered.

func MakeReadWriterChan ¶

func MakeReadWriterChan() (out chan io.ReadWriter)

MakeReadWriterChan returns a new open channel (simply a 'chan io.ReadWriter' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReadWriterBuffer) the channel is unbuffered.

func MakeReaderAtChan ¶

func MakeReaderAtChan() (out chan io.ReaderAt)

MakeReaderAtChan returns a new open channel (simply a 'chan io.ReaderAt' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReaderAtBuffer) the channel is unbuffered.

func MakeReaderChan ¶

func MakeReaderChan() (out chan io.Reader)

MakeReaderChan returns a new open channel (simply a 'chan io.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 MakeReaderFromChan ¶

func MakeReaderFromChan() (out chan io.ReaderFrom)

MakeReaderFromChan returns a new open channel (simply a 'chan io.ReaderFrom' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeReaderFromBuffer) the channel is unbuffered.

func MakeRuneReaderChan ¶

func MakeRuneReaderChan() (out chan io.RuneReader)

MakeRuneReaderChan returns a new open channel (simply a 'chan io.RuneReader' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeRuneReaderBuffer) the channel is unbuffered.

func MakeRuneScannerChan ¶

func MakeRuneScannerChan() (out chan io.RuneScanner)

MakeRuneScannerChan returns a new open channel (simply a 'chan io.RuneScanner' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeRuneScannerBuffer) the channel is unbuffered.

func MakeSectionReaderChan ¶

func MakeSectionReaderChan() (out chan *io.SectionReader)

MakeSectionReaderChan returns a new open channel (simply a 'chan *io.SectionReader' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeSectionReaderBuffer) the channel is unbuffered.

func MakeSeekerChan ¶

func MakeSeekerChan() (out chan io.Seeker)

MakeSeekerChan returns a new open channel (simply a 'chan io.Seeker' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeSeekerBuffer) the channel is unbuffered.

func MakeWriteCloserChan ¶

func MakeWriteCloserChan() (out chan io.WriteCloser)

MakeWriteCloserChan returns a new open channel (simply a 'chan io.WriteCloser' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeWriteCloserBuffer) the channel is unbuffered.

func MakeWriteSeekerChan ¶

func MakeWriteSeekerChan() (out chan io.WriteSeeker)

MakeWriteSeekerChan returns a new open channel (simply a 'chan io.WriteSeeker' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeWriteSeekerBuffer) the channel is unbuffered.

func MakeWriterAtChan ¶

func MakeWriterAtChan() (out chan io.WriterAt)

MakeWriterAtChan returns a new open channel (simply a 'chan io.WriterAt' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeWriterAtBuffer) the channel is unbuffered.

func MakeWriterChan ¶

func MakeWriterChan() (out chan io.Writer)

MakeWriterChan returns a new open channel (simply a 'chan io.Writer' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeWriterBuffer) the channel is unbuffered.

func MakeWriterToChan ¶

func MakeWriterToChan() (out chan io.WriterTo)

MakeWriterToChan returns a new open channel (simply a 'chan io.WriterTo' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeWriterToBuffer) the channel is unbuffered.

func PipeByteReaderBuffer ¶

func PipeByteReaderBuffer(inp <-chan io.ByteReader, cap int) (out <-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) (out1, out2 <-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) (out <-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) (out <-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) (out1, out2 <-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) (out <-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) (out <-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) (out1, out2 <-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) (out <-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 PipeCloserBuffer ¶

func PipeCloserBuffer(inp <-chan io.Closer, cap int) (out <-chan io.Closer)

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

func PipeCloserFork ¶

func PipeCloserFork(inp <-chan io.Closer) (out1, out2 <-chan io.Closer)

PipeCloserFork 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 PipeCloserFunc ¶

func PipeCloserFunc(inp <-chan io.Closer, act func(a io.Closer) io.Closer) (out <-chan io.Closer)

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

func PipeLimitedReaderBuffer ¶

func PipeLimitedReaderBuffer(inp <-chan *io.LimitedReader, cap int) (out <-chan *io.LimitedReader)

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

func PipeLimitedReaderFork ¶

func PipeLimitedReaderFork(inp <-chan *io.LimitedReader) (out1, out2 <-chan *io.LimitedReader)

PipeLimitedReaderFork 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 PipeLimitedReaderFunc ¶

func PipeLimitedReaderFunc(inp <-chan *io.LimitedReader, act func(a *io.LimitedReader) *io.LimitedReader) (out <-chan *io.LimitedReader)

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

func PipePipeReaderBuffer ¶

func PipePipeReaderBuffer(inp <-chan *io.PipeReader, cap int) (out <-chan *io.PipeReader)

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

func PipePipeReaderFork ¶

func PipePipeReaderFork(inp <-chan *io.PipeReader) (out1, out2 <-chan *io.PipeReader)

PipePipeReaderFork 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 PipePipeReaderFunc ¶

func PipePipeReaderFunc(inp <-chan *io.PipeReader, act func(a *io.PipeReader) *io.PipeReader) (out <-chan *io.PipeReader)

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

func PipePipeWriterBuffer ¶

func PipePipeWriterBuffer(inp <-chan *io.PipeWriter, cap int) (out <-chan *io.PipeWriter)

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

func PipePipeWriterFork ¶

func PipePipeWriterFork(inp <-chan *io.PipeWriter) (out1, out2 <-chan *io.PipeWriter)

PipePipeWriterFork 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 PipePipeWriterFunc ¶

func PipePipeWriterFunc(inp <-chan *io.PipeWriter, act func(a *io.PipeWriter) *io.PipeWriter) (out <-chan *io.PipeWriter)

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

func PipeReadCloserBuffer ¶

func PipeReadCloserBuffer(inp <-chan io.ReadCloser, cap int) (out <-chan io.ReadCloser)

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

func PipeReadCloserFork ¶

func PipeReadCloserFork(inp <-chan io.ReadCloser) (out1, out2 <-chan io.ReadCloser)

PipeReadCloserFork 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 PipeReadCloserFunc ¶

func PipeReadCloserFunc(inp <-chan io.ReadCloser, act func(a io.ReadCloser) io.ReadCloser) (out <-chan io.ReadCloser)

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

func PipeReadSeekerBuffer ¶

func PipeReadSeekerBuffer(inp <-chan io.ReadSeeker, cap int) (out <-chan io.ReadSeeker)

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

func PipeReadSeekerFork ¶

func PipeReadSeekerFork(inp <-chan io.ReadSeeker) (out1, out2 <-chan io.ReadSeeker)

PipeReadSeekerFork 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 PipeReadSeekerFunc ¶

func PipeReadSeekerFunc(inp <-chan io.ReadSeeker, act func(a io.ReadSeeker) io.ReadSeeker) (out <-chan io.ReadSeeker)

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

func PipeReadWriteCloserBuffer ¶

func PipeReadWriteCloserBuffer(inp <-chan io.ReadWriteCloser, cap int) (out <-chan io.ReadWriteCloser)

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

func PipeReadWriteCloserFork ¶

func PipeReadWriteCloserFork(inp <-chan io.ReadWriteCloser) (out1, out2 <-chan io.ReadWriteCloser)

PipeReadWriteCloserFork 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 PipeReadWriteCloserFunc ¶

func PipeReadWriteCloserFunc(inp <-chan io.ReadWriteCloser, act func(a io.ReadWriteCloser) io.ReadWriteCloser) (out <-chan io.ReadWriteCloser)

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

func PipeReadWriteSeekerBuffer ¶

func PipeReadWriteSeekerBuffer(inp <-chan io.ReadWriteSeeker, cap int) (out <-chan io.ReadWriteSeeker)

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

func PipeReadWriteSeekerFork ¶

func PipeReadWriteSeekerFork(inp <-chan io.ReadWriteSeeker) (out1, out2 <-chan io.ReadWriteSeeker)

PipeReadWriteSeekerFork 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 PipeReadWriteSeekerFunc ¶

func PipeReadWriteSeekerFunc(inp <-chan io.ReadWriteSeeker, act func(a io.ReadWriteSeeker) io.ReadWriteSeeker) (out <-chan io.ReadWriteSeeker)

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

func PipeReadWriterBuffer ¶

func PipeReadWriterBuffer(inp <-chan io.ReadWriter, cap int) (out <-chan io.ReadWriter)

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

func PipeReadWriterFork ¶

func PipeReadWriterFork(inp <-chan io.ReadWriter) (out1, out2 <-chan io.ReadWriter)

PipeReadWriterFork 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 PipeReadWriterFunc ¶

func PipeReadWriterFunc(inp <-chan io.ReadWriter, act func(a io.ReadWriter) io.ReadWriter) (out <-chan io.ReadWriter)

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

func PipeReaderAtBuffer ¶

func PipeReaderAtBuffer(inp <-chan io.ReaderAt, cap int) (out <-chan io.ReaderAt)

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

func PipeReaderAtFork ¶

func PipeReaderAtFork(inp <-chan io.ReaderAt) (out1, out2 <-chan io.ReaderAt)

PipeReaderAtFork 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 PipeReaderAtFunc ¶

func PipeReaderAtFunc(inp <-chan io.ReaderAt, act func(a io.ReaderAt) io.ReaderAt) (out <-chan io.ReaderAt)

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

func PipeReaderBuffer ¶

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

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

func PipeReaderDaisy ¶

func PipeReaderDaisy(inp <-chan *io.PipeReader, tube PipeReaderTube) (out <-chan *io.PipeReader)

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

func PipeReaderDaisyChain ¶

func PipeReaderDaisyChain(inp <-chan *io.PipeReader, tubes ...PipeReaderTube) (out <-chan *io.PipeReader)

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

func PipeReaderFork ¶

func PipeReaderFork(inp <-chan io.Reader) (out1, out2 <-chan io.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 PipeReaderFromBuffer ¶

func PipeReaderFromBuffer(inp <-chan io.ReaderFrom, cap int) (out <-chan io.ReaderFrom)

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

func PipeReaderFromFork ¶

func PipeReaderFromFork(inp <-chan io.ReaderFrom) (out1, out2 <-chan io.ReaderFrom)

PipeReaderFromFork 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 PipeReaderFromFunc ¶

func PipeReaderFromFunc(inp <-chan io.ReaderFrom, act func(a io.ReaderFrom) io.ReaderFrom) (out <-chan io.ReaderFrom)

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

func PipeReaderFunc ¶

func PipeReaderFunc(inp <-chan io.Reader, act func(a io.Reader) io.Reader) (out <-chan io.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 PipeRuneReaderBuffer ¶

func PipeRuneReaderBuffer(inp <-chan io.RuneReader, cap int) (out <-chan io.RuneReader)

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

func PipeRuneReaderFork ¶

func PipeRuneReaderFork(inp <-chan io.RuneReader) (out1, out2 <-chan io.RuneReader)

PipeRuneReaderFork 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 PipeRuneReaderFunc ¶

func PipeRuneReaderFunc(inp <-chan io.RuneReader, act func(a io.RuneReader) io.RuneReader) (out <-chan io.RuneReader)

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

func PipeRuneScannerBuffer ¶

func PipeRuneScannerBuffer(inp <-chan io.RuneScanner, cap int) (out <-chan io.RuneScanner)

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

func PipeRuneScannerFork ¶

func PipeRuneScannerFork(inp <-chan io.RuneScanner) (out1, out2 <-chan io.RuneScanner)

PipeRuneScannerFork 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 PipeRuneScannerFunc ¶

func PipeRuneScannerFunc(inp <-chan io.RuneScanner, act func(a io.RuneScanner) io.RuneScanner) (out <-chan io.RuneScanner)

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

func PipeSectionReaderBuffer ¶

func PipeSectionReaderBuffer(inp <-chan *io.SectionReader, cap int) (out <-chan *io.SectionReader)

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

func PipeSectionReaderFork ¶

func PipeSectionReaderFork(inp <-chan *io.SectionReader) (out1, out2 <-chan *io.SectionReader)

PipeSectionReaderFork 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 PipeSectionReaderFunc ¶

func PipeSectionReaderFunc(inp <-chan *io.SectionReader, act func(a *io.SectionReader) *io.SectionReader) (out <-chan *io.SectionReader)

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

func PipeSeekerBuffer ¶

func PipeSeekerBuffer(inp <-chan io.Seeker, cap int) (out <-chan io.Seeker)

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

func PipeSeekerFork ¶

func PipeSeekerFork(inp <-chan io.Seeker) (out1, out2 <-chan io.Seeker)

PipeSeekerFork 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 PipeSeekerFunc ¶

func PipeSeekerFunc(inp <-chan io.Seeker, act func(a io.Seeker) io.Seeker) (out <-chan io.Seeker)

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

func PipeWriteCloserBuffer ¶

func PipeWriteCloserBuffer(inp <-chan io.WriteCloser, cap int) (out <-chan io.WriteCloser)

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

func PipeWriteCloserFork ¶

func PipeWriteCloserFork(inp <-chan io.WriteCloser) (out1, out2 <-chan io.WriteCloser)

PipeWriteCloserFork 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 PipeWriteCloserFunc ¶

func PipeWriteCloserFunc(inp <-chan io.WriteCloser, act func(a io.WriteCloser) io.WriteCloser) (out <-chan io.WriteCloser)

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

func PipeWriteSeekerBuffer ¶

func PipeWriteSeekerBuffer(inp <-chan io.WriteSeeker, cap int) (out <-chan io.WriteSeeker)

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

func PipeWriteSeekerFork ¶

func PipeWriteSeekerFork(inp <-chan io.WriteSeeker) (out1, out2 <-chan io.WriteSeeker)

PipeWriteSeekerFork 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 PipeWriteSeekerFunc ¶

func PipeWriteSeekerFunc(inp <-chan io.WriteSeeker, act func(a io.WriteSeeker) io.WriteSeeker) (out <-chan io.WriteSeeker)

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

func PipeWriterAtBuffer ¶

func PipeWriterAtBuffer(inp <-chan io.WriterAt, cap int) (out <-chan io.WriterAt)

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

func PipeWriterAtFork ¶

func PipeWriterAtFork(inp <-chan io.WriterAt) (out1, out2 <-chan io.WriterAt)

PipeWriterAtFork 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 PipeWriterAtFunc ¶

func PipeWriterAtFunc(inp <-chan io.WriterAt, act func(a io.WriterAt) io.WriterAt) (out <-chan io.WriterAt)

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

func PipeWriterBuffer ¶

func PipeWriterBuffer(inp <-chan io.Writer, cap int) (out <-chan io.Writer)

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

func PipeWriterDaisy ¶

func PipeWriterDaisy(inp <-chan *io.PipeWriter, tube PipeWriterTube) (out <-chan *io.PipeWriter)

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

func PipeWriterDaisyChain ¶

func PipeWriterDaisyChain(inp <-chan *io.PipeWriter, tubes ...PipeWriterTube) (out <-chan *io.PipeWriter)

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

func PipeWriterFork ¶

func PipeWriterFork(inp <-chan io.Writer) (out1, out2 <-chan io.Writer)

PipeWriterFork 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 PipeWriterFunc ¶

func PipeWriterFunc(inp <-chan io.Writer, act func(a io.Writer) io.Writer) (out <-chan io.Writer)

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

func PipeWriterToBuffer ¶

func PipeWriterToBuffer(inp <-chan io.WriterTo, cap int) (out <-chan io.WriterTo)

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

func PipeWriterToFork ¶

func PipeWriterToFork(inp <-chan io.WriterTo) (out1, out2 <-chan io.WriterTo)

PipeWriterToFork 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 PipeWriterToFunc ¶

func PipeWriterToFunc(inp <-chan io.WriterTo, act func(a io.WriterTo) io.WriterTo) (out <-chan io.WriterTo)

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

func ReadCloserDaisy ¶

func ReadCloserDaisy(inp <-chan io.ReadCloser, tube ReadCloserTube) (out <-chan io.ReadCloser)

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

func ReadCloserDaisyChain ¶

func ReadCloserDaisyChain(inp <-chan io.ReadCloser, tubes ...ReadCloserTube) (out <-chan io.ReadCloser)

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

func ReadSeekerDaisy ¶

func ReadSeekerDaisy(inp <-chan io.ReadSeeker, tube ReadSeekerTube) (out <-chan io.ReadSeeker)

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

func ReadSeekerDaisyChain ¶

func ReadSeekerDaisyChain(inp <-chan io.ReadSeeker, tubes ...ReadSeekerTube) (out <-chan io.ReadSeeker)

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

func ReadWriteCloserDaisy ¶

func ReadWriteCloserDaisy(inp <-chan io.ReadWriteCloser, tube ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)

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

func ReadWriteCloserDaisyChain ¶

func ReadWriteCloserDaisyChain(inp <-chan io.ReadWriteCloser, tubes ...ReadWriteCloserTube) (out <-chan io.ReadWriteCloser)

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

func ReadWriteSeekerDaisy ¶

func ReadWriteSeekerDaisy(inp <-chan io.ReadWriteSeeker, tube ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)

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

func ReadWriteSeekerDaisyChain ¶

func ReadWriteSeekerDaisyChain(inp <-chan io.ReadWriteSeeker, tubes ...ReadWriteSeekerTube) (out <-chan io.ReadWriteSeeker)

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

func ReadWriterDaisy ¶

func ReadWriterDaisy(inp <-chan io.ReadWriter, tube ReadWriterTube) (out <-chan io.ReadWriter)

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

func ReadWriterDaisyChain ¶

func ReadWriterDaisyChain(inp <-chan io.ReadWriter, tubes ...ReadWriterTube) (out <-chan io.ReadWriter)

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

func ReaderAtDaisy ¶

func ReaderAtDaisy(inp <-chan io.ReaderAt, tube ReaderAtTube) (out <-chan io.ReaderAt)

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

func ReaderAtDaisyChain ¶

func ReaderAtDaisyChain(inp <-chan io.ReaderAt, tubes ...ReaderAtTube) (out <-chan io.ReaderAt)

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

func ReaderDaisy ¶

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

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

func ReaderDaisyChain ¶

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

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

func ReaderFromDaisy ¶

func ReaderFromDaisy(inp <-chan io.ReaderFrom, tube ReaderFromTube) (out <-chan io.ReaderFrom)

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

func ReaderFromDaisyChain ¶

func ReaderFromDaisyChain(inp <-chan io.ReaderFrom, tubes ...ReaderFromTube) (out <-chan io.ReaderFrom)

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

func RuneReaderDaisy ¶

func RuneReaderDaisy(inp <-chan io.RuneReader, tube RuneReaderTube) (out <-chan io.RuneReader)

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

func RuneReaderDaisyChain ¶

func RuneReaderDaisyChain(inp <-chan io.RuneReader, tubes ...RuneReaderTube) (out <-chan io.RuneReader)

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

func RuneScannerDaisy ¶

func RuneScannerDaisy(inp <-chan io.RuneScanner, tube RuneScannerTube) (out <-chan io.RuneScanner)

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

func RuneScannerDaisyChain ¶

func RuneScannerDaisyChain(inp <-chan io.RuneScanner, tubes ...RuneScannerTube) (out <-chan io.RuneScanner)

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

func SectionReaderDaisy ¶

func SectionReaderDaisy(inp <-chan *io.SectionReader, tube SectionReaderTube) (out <-chan *io.SectionReader)

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

func SectionReaderDaisyChain ¶

func SectionReaderDaisyChain(inp <-chan *io.SectionReader, tubes ...SectionReaderTube) (out <-chan *io.SectionReader)

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

func SeekerDaisy ¶

func SeekerDaisy(inp <-chan io.Seeker, tube SeekerTube) (out <-chan io.Seeker)

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

func SeekerDaisyChain ¶

func SeekerDaisyChain(inp <-chan io.Seeker, tubes ...SeekerTube) (out <-chan io.Seeker)

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

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 SendProxyCloser ¶

func SendProxyCloser(out chan<- io.Closer) chan<- io.Closer

SendProxyCloser 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 SendProxyLimitedReader ¶

func SendProxyLimitedReader(out chan<- *io.LimitedReader) chan<- *io.LimitedReader

SendProxyLimitedReader 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 SendProxyPipeReader ¶

func SendProxyPipeReader(out chan<- *io.PipeReader) chan<- *io.PipeReader

SendProxyPipeReader 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 SendProxyPipeWriter ¶

func SendProxyPipeWriter(out chan<- *io.PipeWriter) chan<- *io.PipeWriter

SendProxyPipeWriter 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 SendProxyReadCloser ¶

func SendProxyReadCloser(out chan<- io.ReadCloser) chan<- io.ReadCloser

SendProxyReadCloser 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 SendProxyReadSeeker ¶

func SendProxyReadSeeker(out chan<- io.ReadSeeker) chan<- io.ReadSeeker

SendProxyReadSeeker 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 SendProxyReadWriteCloser ¶

func SendProxyReadWriteCloser(out chan<- io.ReadWriteCloser) chan<- io.ReadWriteCloser

SendProxyReadWriteCloser 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 SendProxyReadWriteSeeker ¶

func SendProxyReadWriteSeeker(out chan<- io.ReadWriteSeeker) chan<- io.ReadWriteSeeker

SendProxyReadWriteSeeker 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 SendProxyReadWriter ¶

func SendProxyReadWriter(out chan<- io.ReadWriter) chan<- io.ReadWriter

SendProxyReadWriter 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<- io.Reader) chan<- io.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"

func SendProxyReaderAt ¶

func SendProxyReaderAt(out chan<- io.ReaderAt) chan<- io.ReaderAt

SendProxyReaderAt 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 SendProxyReaderFrom ¶

func SendProxyReaderFrom(out chan<- io.ReaderFrom) chan<- io.ReaderFrom

SendProxyReaderFrom 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 SendProxyRuneReader ¶

func SendProxyRuneReader(out chan<- io.RuneReader) chan<- io.RuneReader

SendProxyRuneReader 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 SendProxyRuneScanner ¶

func SendProxyRuneScanner(out chan<- io.RuneScanner) chan<- io.RuneScanner

SendProxyRuneScanner 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 SendProxySectionReader ¶

func SendProxySectionReader(out chan<- *io.SectionReader) chan<- *io.SectionReader

SendProxySectionReader 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 SendProxySeeker ¶

func SendProxySeeker(out chan<- io.Seeker) chan<- io.Seeker

SendProxySeeker 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 SendProxyWriteCloser ¶

func SendProxyWriteCloser(out chan<- io.WriteCloser) chan<- io.WriteCloser

SendProxyWriteCloser 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 SendProxyWriteSeeker ¶

func SendProxyWriteSeeker(out chan<- io.WriteSeeker) chan<- io.WriteSeeker

SendProxyWriteSeeker 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 SendProxyWriter ¶

func SendProxyWriter(out chan<- io.Writer) chan<- io.Writer

SendProxyWriter 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 SendProxyWriterAt ¶

func SendProxyWriterAt(out chan<- io.WriterAt) chan<- io.WriterAt

SendProxyWriterAt 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 SendProxyWriterTo ¶

func SendProxyWriterTo(out chan<- io.WriterTo) chan<- io.WriterTo

SendProxyWriterTo 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 WriteCloserDaisy ¶

func WriteCloserDaisy(inp <-chan io.WriteCloser, tube WriteCloserTube) (out <-chan io.WriteCloser)

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

func WriteCloserDaisyChain ¶

func WriteCloserDaisyChain(inp <-chan io.WriteCloser, tubes ...WriteCloserTube) (out <-chan io.WriteCloser)

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

func WriteSeekerDaisy ¶

func WriteSeekerDaisy(inp <-chan io.WriteSeeker, tube WriteSeekerTube) (out <-chan io.WriteSeeker)

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

func WriteSeekerDaisyChain ¶

func WriteSeekerDaisyChain(inp <-chan io.WriteSeeker, tubes ...WriteSeekerTube) (out <-chan io.WriteSeeker)

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

func WriterAtDaisy ¶

func WriterAtDaisy(inp <-chan io.WriterAt, tube WriterAtTube) (out <-chan io.WriterAt)

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

func WriterAtDaisyChain ¶

func WriterAtDaisyChain(inp <-chan io.WriterAt, tubes ...WriterAtTube) (out <-chan io.WriterAt)

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

func WriterDaisy ¶

func WriterDaisy(inp <-chan io.Writer, tube WriterTube) (out <-chan io.Writer)

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

func WriterDaisyChain ¶

func WriterDaisyChain(inp <-chan io.Writer, tubes ...WriterTube) (out <-chan io.Writer)

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

func WriterToDaisy ¶

func WriterToDaisy(inp <-chan io.WriterTo, tube WriterToTube) (out <-chan io.WriterTo)

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

func WriterToDaisyChain ¶

func WriterToDaisyChain(inp <-chan io.WriterTo, tubes ...WriterToTube) (out <-chan io.WriterTo)

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

Types ¶

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 CloserTube ¶

type CloserTube func(inp <-chan io.Closer, out <-chan io.Closer)

CloserTube is the signature for a pipe function.

type LimitedReaderTube ¶

type LimitedReaderTube func(inp <-chan *io.LimitedReader, out <-chan *io.LimitedReader)

LimitedReaderTube is the signature for a pipe function.

type PipeReaderTube ¶

type PipeReaderTube func(inp <-chan *io.PipeReader, out <-chan *io.PipeReader)

PipeReaderTube is the signature for a pipe function.

type PipeWriterTube ¶

type PipeWriterTube func(inp <-chan *io.PipeWriter, out <-chan *io.PipeWriter)

PipeWriterTube is the signature for a pipe function.

type ReadCloserTube ¶

type ReadCloserTube func(inp <-chan io.ReadCloser, out <-chan io.ReadCloser)

ReadCloserTube is the signature for a pipe function.

type ReadSeekerTube ¶

type ReadSeekerTube func(inp <-chan io.ReadSeeker, out <-chan io.ReadSeeker)

ReadSeekerTube is the signature for a pipe function.

type ReadWriteCloserTube ¶

type ReadWriteCloserTube func(inp <-chan io.ReadWriteCloser, out <-chan io.ReadWriteCloser)

ReadWriteCloserTube is the signature for a pipe function.

type ReadWriteSeekerTube ¶

type ReadWriteSeekerTube func(inp <-chan io.ReadWriteSeeker, out <-chan io.ReadWriteSeeker)

ReadWriteSeekerTube is the signature for a pipe function.

type ReadWriterTube ¶

type ReadWriterTube func(inp <-chan io.ReadWriter, out <-chan io.ReadWriter)

ReadWriterTube is the signature for a pipe function.

type ReaderAtTube ¶

type ReaderAtTube func(inp <-chan io.ReaderAt, out <-chan io.ReaderAt)

ReaderAtTube is the signature for a pipe function.

type ReaderFromTube ¶

type ReaderFromTube func(inp <-chan io.ReaderFrom, out <-chan io.ReaderFrom)

ReaderFromTube is the signature for a pipe function.

type ReaderTube ¶

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

ReaderTube is the signature for a pipe function.

type RuneReaderTube ¶

type RuneReaderTube func(inp <-chan io.RuneReader, out <-chan io.RuneReader)

RuneReaderTube is the signature for a pipe function.

type RuneScannerTube ¶

type RuneScannerTube func(inp <-chan io.RuneScanner, out <-chan io.RuneScanner)

RuneScannerTube is the signature for a pipe function.

type SectionReaderTube ¶

type SectionReaderTube func(inp <-chan *io.SectionReader, out <-chan *io.SectionReader)

SectionReaderTube is the signature for a pipe function.

type SeekerTube ¶

type SeekerTube func(inp <-chan io.Seeker, out <-chan io.Seeker)

SeekerTube is the signature for a pipe function.

type WriteCloserTube ¶

type WriteCloserTube func(inp <-chan io.WriteCloser, out <-chan io.WriteCloser)

WriteCloserTube is the signature for a pipe function.

type WriteSeekerTube ¶

type WriteSeekerTube func(inp <-chan io.WriteSeeker, out <-chan io.WriteSeeker)

WriteSeekerTube is the signature for a pipe function.

type WriterAtTube ¶

type WriterAtTube func(inp <-chan io.WriterAt, out <-chan io.WriterAt)

WriterAtTube is the signature for a pipe function.

type WriterToTube ¶

type WriterToTube func(inp <-chan io.WriterTo, out <-chan io.WriterTo)

WriterToTube is the signature for a pipe function.

type WriterTube ¶

type WriterTube func(inp <-chan io.Writer, out <-chan io.Writer)

WriterTube 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