zip

package
v0.0.0-...-5012a73 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 20, 2019 License: MIT Imports: 2 Imported by: 0

Documentation

Index

Constants

View Source
const FileCAP = 10

FileCAP is the capacity of the buffered proxy channel

View Source
const FileHeaderCAP = 10

FileHeaderCAP is the capacity of the buffered proxy channel

View Source
const FileHeaderQUE = 16

FileHeaderQUE is the allocated size of the circular queue

View Source
const FileQUE = 16

FileQUE 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 ReaderCAP = 10

ReaderCAP is the capacity of the buffered proxy channel

View Source
const ReaderQUE = 16

ReaderQUE is the allocated size of the circular queue

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

Variables

This section is empty.

Functions

func ChanFile

func ChanFile(inp ...*zip.File) chan *zip.File

ChanFile returns a channel to receive all inputs before close.

func ChanFileFuncErr

func ChanFileFuncErr(act func() (*zip.File, error)) <-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) <-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)) <-chan *zip.File

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

func ChanFileHeader

func ChanFileHeader(inp ...*zip.FileHeader) chan *zip.FileHeader

ChanFileHeader returns a channel to receive all inputs before close.

func ChanFileHeaderFuncErr

func ChanFileHeaderFuncErr(act func() (*zip.FileHeader, error)) <-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) <-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)) <-chan *zip.FileHeader

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

func ChanFileHeaderSlice

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

ChanFileHeaderSlice returns a channel to receive all inputs before close.

func ChanFileSlice

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

ChanFileSlice returns a channel to receive all inputs before close.

func ChanReadCloser

func ChanReadCloser(inp ...*zip.ReadCloser) chan *zip.ReadCloser

ChanReadCloser returns a channel to receive all inputs before close.

func ChanReadCloserFuncErr

func ChanReadCloserFuncErr(act func() (*zip.ReadCloser, error)) <-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) <-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)) <-chan *zip.ReadCloser

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

func ChanReadCloserSlice

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

ChanReadCloserSlice returns a channel to receive all inputs before close.

func ChanReader

func ChanReader(inp ...*zip.Reader) chan *zip.Reader

ChanReader returns a channel to receive all inputs before close.

func ChanReaderFuncErr

func ChanReaderFuncErr(act func() (*zip.Reader, error)) <-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) <-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)) <-chan *zip.Reader

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

func ChanReaderSlice

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

ChanReaderSlice returns a channel to receive all inputs before close.

func ChanWriter

func ChanWriter(inp ...*zip.Writer) chan *zip.Writer

ChanWriter returns a channel to receive all inputs before close.

func ChanWriterFuncErr

func ChanWriterFuncErr(act func() (*zip.Writer, error)) <-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) <-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)) <-chan *zip.Writer

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

func ChanWriterSlice

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

ChanWriterSlice returns a channel to receive all inputs before close.

func DoneFile

func DoneFile(inp <-chan *zip.File) 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)) 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) 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)) 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) 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) 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) 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)) 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) 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) 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)) 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) 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) 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)) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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() 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() 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() 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() 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() 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) 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) (chan *zip.File, 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) 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) 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) (chan *zip.FileHeader, 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) 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) 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) (chan *zip.ReadCloser, 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) 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) 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) (chan *zip.Reader, 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) 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) 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) (chan *zip.Writer, 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) 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.

Types

type FileHeaderTube

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

FileHeaderTube is the signature for a pipe function.

type FileTube

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

FileTube is the signature for a pipe function.

type ReadCloserTube

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

ReadCloserTube is the signature for a pipe function.

type ReaderTube

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

ReaderTube is the signature for a pipe function.

type WriterTube

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

WriterTube is the signature for a pipe function.

Jump to

Keyboard shortcuts

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