zip

func ChanFile ¶

func ChanFile(inp ...*zip.File) (out <-chan *zip.File)

ChanFile returns a channel to receive all inputs before close.

func ChanFileFuncErr ¶

func ChanFileFuncErr(act func() (*zip.File, error)) (out <-chan *zip.File)

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

func ChanFileFuncNil ¶

func ChanFileFuncNil(act func() *zip.File) (out <-chan *zip.File)

ChanFileFuncNil returns a channel to receive all results of act until nil before close.

func ChanFileFuncNok ¶

func ChanFileFuncNok(act func() (*zip.File, bool)) (out <-chan *zip.File)

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

func ChanFileHeader ¶

func ChanFileHeader(inp ...*zip.FileHeader) (out <-chan *zip.FileHeader)

ChanFileHeader returns a channel to receive all inputs before close.

func ChanFileHeaderFuncErr ¶

func ChanFileHeaderFuncErr(act func() (*zip.FileHeader, error)) (out <-chan *zip.FileHeader)

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

func ChanFileHeaderFuncNil ¶

func ChanFileHeaderFuncNil(act func() *zip.FileHeader) (out <-chan *zip.FileHeader)

ChanFileHeaderFuncNil returns a channel to receive all results of act until nil before close.

func ChanFileHeaderFuncNok ¶

func ChanFileHeaderFuncNok(act func() (*zip.FileHeader, bool)) (out <-chan *zip.FileHeader)

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

func ChanFileHeaderSlice ¶

func ChanFileHeaderSlice(inp ...[]*zip.FileHeader) (out <-chan *zip.FileHeader)

ChanFileHeaderSlice returns a channel to receive all inputs before close.

func ChanFileSlice ¶

func ChanFileSlice(inp ...[]*zip.File) (out <-chan *zip.File)

ChanFileSlice returns a channel to receive all inputs before close.

func ChanReadCloser ¶

func ChanReadCloser(inp ...*zip.ReadCloser) (out <-chan *zip.ReadCloser)

ChanReadCloser returns a channel to receive all inputs before close.

func ChanReadCloserFuncErr ¶

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

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

func ChanReadCloserFuncNil ¶

func ChanReadCloserFuncNil(act func() *zip.ReadCloser) (out <-chan *zip.ReadCloser)

ChanReadCloserFuncNil returns a channel to receive all results of act until nil before close.

func ChanReadCloserFuncNok ¶

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

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

func ChanReadCloserSlice ¶

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

ChanReadCloserSlice returns a channel to receive all inputs before close.

func ChanReader ¶

func ChanReader(inp ...*zip.Reader) (out <-chan *zip.Reader)

ChanReader returns a channel to receive all inputs before close.

func ChanReaderFuncErr ¶

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

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

func ChanReaderFuncNil ¶

func ChanReaderFuncNil(act func() *zip.Reader) (out <-chan *zip.Reader)

ChanReaderFuncNil returns a channel to receive all results of act until nil before close.

func ChanReaderFuncNok ¶

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

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

func ChanReaderSlice ¶

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

ChanReaderSlice returns a channel to receive all inputs before close.

func ChanWriter ¶

func ChanWriter(inp ...*zip.Writer) (out <-chan *zip.Writer)

ChanWriter returns a channel to receive all inputs before close.

func ChanWriterFuncErr ¶

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

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

func ChanWriterFuncNil ¶

func ChanWriterFuncNil(act func() *zip.Writer) (out <-chan *zip.Writer)

ChanWriterFuncNil returns a channel to receive all results of act until nil before close.

func ChanWriterFuncNok ¶

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

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

func ChanWriterSlice ¶

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

ChanWriterSlice returns a channel to receive all inputs before close.

func DoneFile ¶

func DoneFile(inp <-chan *zip.File) (done <-chan struct{})

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

func DoneFileFunc ¶

func DoneFileFunc(inp <-chan *zip.File, act func(a *zip.File)) (out <-chan struct{})

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

func DoneFileHeader ¶

func DoneFileHeader(inp <-chan *zip.FileHeader) (done <-chan struct{})

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

func DoneFileHeaderFunc ¶

func DoneFileHeaderFunc(inp <-chan *zip.FileHeader, act func(a *zip.FileHeader)) (out <-chan struct{})

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

func DoneFileHeaderSlice ¶

func DoneFileHeaderSlice(inp <-chan *zip.FileHeader) (done <-chan []*zip.FileHeader)

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

func DoneFileSlice ¶

func DoneFileSlice(inp <-chan *zip.File) (done <-chan []*zip.File)

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

func DoneReadCloser ¶

func DoneReadCloser(inp <-chan *zip.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 *zip.ReadCloser, act func(a *zip.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 *zip.ReadCloser) (done <-chan []*zip.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 DoneReader ¶

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

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

func DoneReaderFunc ¶

func DoneReaderFunc(inp <-chan *zip.Reader, act func(a *zip.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 *zip.Reader) (done <-chan []*zip.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 DoneWriter ¶

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

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

func DoneWriterFunc ¶

func DoneWriterFunc(inp <-chan *zip.Writer, act func(a *zip.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 *zip.Writer) (done <-chan []*zip.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 FileDaisy ¶

func FileDaisy(inp <-chan *zip.File, tube FileTube) (out <-chan *zip.File)

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

func FileDaisyChain ¶

func FileDaisyChain(inp <-chan *zip.File, tubes ...FileTube) (out <-chan *zip.File)

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

func FileHeaderDaisy ¶

func FileHeaderDaisy(inp <-chan *zip.FileHeader, tube FileHeaderTube) (out <-chan *zip.FileHeader)

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

func FileHeaderDaisyChain ¶

func FileHeaderDaisyChain(inp <-chan *zip.FileHeader, tubes ...FileHeaderTube) (out <-chan *zip.FileHeader)

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

func JoinFile ¶

func JoinFile(out chan<- *zip.File, inp ...*zip.File) (done <-chan struct{})

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

func JoinFileChan ¶

func JoinFileChan(out chan<- *zip.File, inp <-chan *zip.File) (done <-chan struct{})

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

func JoinFileHeader ¶

func JoinFileHeader(out chan<- *zip.FileHeader, inp ...*zip.FileHeader) (done <-chan struct{})

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

func JoinFileHeaderChan ¶

func JoinFileHeaderChan(out chan<- *zip.FileHeader, inp <-chan *zip.FileHeader) (done <-chan struct{})

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

func JoinFileHeaderSlice ¶

func JoinFileHeaderSlice(out chan<- *zip.FileHeader, inp ...[]*zip.FileHeader) (done <-chan struct{})

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

func JoinFileSlice ¶

func JoinFileSlice(out chan<- *zip.File, inp ...[]*zip.File) (done <-chan struct{})

JoinFileSlice 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<- *zip.ReadCloser, inp ...*zip.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<- *zip.ReadCloser, inp <-chan *zip.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<- *zip.ReadCloser, inp ...[]*zip.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 JoinReader ¶

func JoinReader(out chan<- *zip.Reader, inp ...*zip.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 JoinReaderChan ¶

func JoinReaderChan(out chan<- *zip.Reader, inp <-chan *zip.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 JoinReaderSlice ¶

func JoinReaderSlice(out chan<- *zip.Reader, inp ...[]*zip.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 JoinWriter ¶

func JoinWriter(out chan<- *zip.Writer, inp ...*zip.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 JoinWriterChan ¶

func JoinWriterChan(out chan<- *zip.Writer, inp <-chan *zip.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<- *zip.Writer, inp ...[]*zip.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 MakeFileChan ¶

func MakeFileChan() (out chan *zip.File)

MakeFileChan returns a new open channel (simply a 'chan *zip.File' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFileHeaderChan ¶

func MakeFileHeaderChan() (out chan *zip.FileHeader)

MakeFileHeaderChan returns a new open channel (simply a 'chan *zip.FileHeader' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeReadCloserChan ¶

func MakeReadCloserChan() (out chan *zip.ReadCloser)

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

func MakeReaderChan() (out chan *zip.Reader)

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

func MakeWriterChan() (out chan *zip.Writer)

MakeWriterChan returns a new open channel (simply a 'chan *zip.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 PipeFileBuffer ¶

func PipeFileBuffer(inp <-chan *zip.File, cap int) (out <-chan *zip.File)

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

func PipeFileFork ¶

func PipeFileFork(inp <-chan *zip.File) (out1, out2 <-chan *zip.File)

PipeFileFork 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 PipeFileFunc ¶

func PipeFileFunc(inp <-chan *zip.File, act func(a *zip.File) *zip.File) (out <-chan *zip.File)

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

func PipeFileHeaderBuffer ¶

func PipeFileHeaderBuffer(inp <-chan *zip.FileHeader, cap int) (out <-chan *zip.FileHeader)

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

func PipeFileHeaderFork ¶

func PipeFileHeaderFork(inp <-chan *zip.FileHeader) (out1, out2 <-chan *zip.FileHeader)

PipeFileHeaderFork 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 PipeFileHeaderFunc ¶

func PipeFileHeaderFunc(inp <-chan *zip.FileHeader, act func(a *zip.FileHeader) *zip.FileHeader) (out <-chan *zip.FileHeader)

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

func PipeReadCloserBuffer ¶

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

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

func PipeReadCloserFork ¶

func PipeReadCloserFork(inp <-chan *zip.ReadCloser) (out1, out2 <-chan *zip.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 *zip.ReadCloser, act func(a *zip.ReadCloser) *zip.ReadCloser) (out <-chan *zip.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 PipeReaderBuffer ¶

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

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

func PipeReaderFork ¶

func PipeReaderFork(inp <-chan *zip.Reader) (out1, out2 <-chan *zip.Reader)

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

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

func PipeReaderFunc ¶

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

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

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

func PipeWriterFork ¶

func PipeWriterFork(inp <-chan *zip.Writer) (out1, out2 <-chan *zip.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 *zip.Writer, act func(a *zip.Writer) *zip.Writer) (out <-chan *zip.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 ReadCloserDaisy ¶

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

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

func ReadCloserDaisyChain ¶

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

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

func ReaderDaisy ¶

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

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

func ReaderDaisyChain ¶

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

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

func SendProxyFile ¶

func SendProxyFile(out chan<- *zip.File) chan<- *zip.File

SendProxyFile 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 SendProxyFileHeader ¶

func SendProxyFileHeader(out chan<- *zip.FileHeader) chan<- *zip.FileHeader

SendProxyFileHeader 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<- *zip.ReadCloser) chan<- *zip.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 SendProxyReader ¶

func SendProxyReader(out chan<- *zip.Reader) chan<- *zip.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 SendProxyWriter ¶

func SendProxyWriter(out chan<- *zip.Writer) chan<- *zip.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 WriterDaisy ¶

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

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

func WriterDaisyChain ¶

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

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