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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.