zip

Documentation

Index

• type DChFile
  • func MakeDemandFileBuff(cap int) *DChFile
  • func MakeDemandFileChan() *DChFile
  • func (c *DChFile) ProvideFile(dat *zip.File)
  • func (c *DChFile) RequestFile() (dat *zip.File)
  • func (c *DChFile) TryFile() (dat *zip.File, open bool)
• type DChFileHeader
  • func MakeDemandFileHeaderBuff(cap int) *DChFileHeader
  • func MakeDemandFileHeaderChan() *DChFileHeader
  • func (c *DChFileHeader) ProvideFileHeader(dat *zip.FileHeader)
  • func (c *DChFileHeader) RequestFileHeader() (dat *zip.FileHeader)
  • func (c *DChFileHeader) TryFileHeader() (dat *zip.FileHeader, open bool)
• type DChReadCloser
  • func MakeDemandReadCloserBuff(cap int) *DChReadCloser
  • func MakeDemandReadCloserChan() *DChReadCloser
  • func (c *DChReadCloser) ProvideReadCloser(dat *zip.ReadCloser)
  • func (c *DChReadCloser) RequestReadCloser() (dat *zip.ReadCloser)
  • func (c *DChReadCloser) TryReadCloser() (dat *zip.ReadCloser, open bool)
• type DChReader
  • func MakeDemandReaderBuff(cap int) *DChReader
  • func MakeDemandReaderChan() *DChReader
  • func (c *DChReader) ProvideReader(dat *zip.Reader)
  • func (c *DChReader) RequestReader() (dat *zip.Reader)
  • func (c *DChReader) TryReader() (dat *zip.Reader, open bool)
• type DChWriter
  • func MakeDemandWriterBuff(cap int) *DChWriter
  • func MakeDemandWriterChan() *DChWriter
  • func (c *DChWriter) ProvideWriter(dat *zip.Writer)
  • func (c *DChWriter) RequestWriter() (dat *zip.Writer)
  • func (c *DChWriter) TryWriter() (dat *zip.Writer, open bool)
• type FileChan
• type FileHeaderChan
• type FileHeaderROnlyChan
• type FileHeaderSOnlyChan
• type FileROnlyChan
• type FileSOnlyChan
• type ReadCloserChan
• type ReadCloserROnlyChan
• type ReadCloserSOnlyChan
• type ReaderChan
• type ReaderROnlyChan
• type ReaderSOnlyChan
• type WriterChan
• type WriterROnlyChan
• type WriterSOnlyChan

Types

type DChFile

type DChFile struct {
	// contains filtered or unexported fields
}

DChFile is a demand channel

func MakeDemandFileBuff

func MakeDemandFileBuff(cap int) *DChFile

MakeDemandFileBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandFileChan

func MakeDemandFileChan() *DChFile

MakeDemandFileChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChFile) ProvideFile

func (c *DChFile) ProvideFile(dat *zip.File)

ProvideFile is the send function - aka "MyKind <- some File"

func (*DChFile) RequestFile

func (c *DChFile) RequestFile() (dat *zip.File)

RequestFile is the receive function - aka "some File <- MyKind"

func (*DChFile) TryFile

func (c *DChFile) TryFile() (dat *zip.File, open bool)

TryFile is the comma-ok multi-valued form of RequestFile and reports whether a received value was sent before the File channel was closed.

type DChFileHeader

type DChFileHeader struct {
	// contains filtered or unexported fields
}

DChFileHeader is a demand channel

func MakeDemandFileHeaderBuff

func MakeDemandFileHeaderBuff(cap int) *DChFileHeader

MakeDemandFileHeaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandFileHeaderChan

func MakeDemandFileHeaderChan() *DChFileHeader

MakeDemandFileHeaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChFileHeader) ProvideFileHeader

func (c *DChFileHeader) ProvideFileHeader(dat *zip.FileHeader)

ProvideFileHeader is the send function - aka "MyKind <- some FileHeader"

func (*DChFileHeader) RequestFileHeader

func (c *DChFileHeader) RequestFileHeader() (dat *zip.FileHeader)

RequestFileHeader is the receive function - aka "some FileHeader <- MyKind"

func (*DChFileHeader) TryFileHeader

func (c *DChFileHeader) TryFileHeader() (dat *zip.FileHeader, open bool)

TryFileHeader is the comma-ok multi-valued form of RequestFileHeader and reports whether a received value was sent before the FileHeader channel was closed.

type DChReadCloser

type DChReadCloser struct {
	// contains filtered or unexported fields
}

DChReadCloser is a demand channel

func MakeDemandReadCloserBuff

func MakeDemandReadCloserBuff(cap int) *DChReadCloser

MakeDemandReadCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReadCloserChan

func MakeDemandReadCloserChan() *DChReadCloser

MakeDemandReadCloserChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReadCloser) ProvideReadCloser

func (c *DChReadCloser) ProvideReadCloser(dat *zip.ReadCloser)

ProvideReadCloser is the send function - aka "MyKind <- some ReadCloser"

func (*DChReadCloser) RequestReadCloser

func (c *DChReadCloser) RequestReadCloser() (dat *zip.ReadCloser)

RequestReadCloser is the receive function - aka "some ReadCloser <- MyKind"

func (*DChReadCloser) TryReadCloser

func (c *DChReadCloser) TryReadCloser() (dat *zip.ReadCloser, open bool)

TryReadCloser is the comma-ok multi-valued form of RequestReadCloser and reports whether a received value was sent before the ReadCloser channel was closed.

type DChReader

type DChReader struct {
	// contains filtered or unexported fields
}

DChReader is a demand channel

func MakeDemandReaderBuff

func MakeDemandReaderBuff(cap int) *DChReader

MakeDemandReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandReaderChan

func MakeDemandReaderChan() *DChReader

MakeDemandReaderChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChReader) ProvideReader

func (c *DChReader) ProvideReader(dat *zip.Reader)

ProvideReader is the send function - aka "MyKind <- some Reader"

func (*DChReader) RequestReader

func (c *DChReader) RequestReader() (dat *zip.Reader)

RequestReader is the receive function - aka "some Reader <- MyKind"

func (*DChReader) TryReader

func (c *DChReader) TryReader() (dat *zip.Reader, open bool)

TryReader is the comma-ok multi-valued form of RequestReader and reports whether a received value was sent before the Reader channel was closed.

type DChWriter

type DChWriter struct {
	// contains filtered or unexported fields
}

DChWriter is a demand channel

func MakeDemandWriterBuff

func MakeDemandWriterBuff(cap int) *DChWriter

MakeDemandWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) demand channel

func MakeDemandWriterChan

func MakeDemandWriterChan() *DChWriter

MakeDemandWriterChan returns a (pointer to a) fresh unbuffered demand channel

func (*DChWriter) ProvideWriter

func (c *DChWriter) ProvideWriter(dat *zip.Writer)

ProvideWriter is the send function - aka "MyKind <- some Writer"

func (*DChWriter) RequestWriter

func (c *DChWriter) RequestWriter() (dat *zip.Writer)

RequestWriter is the receive function - aka "some Writer <- MyKind"

func (*DChWriter) TryWriter

func (c *DChWriter) TryWriter() (dat *zip.Writer, open bool)

TryWriter is the comma-ok multi-valued form of RequestWriter and reports whether a received value was sent before the Writer channel was closed.

type FileChan

type FileChan interface {
	FileROnlyChan // aka "<-chan" - receive only
	FileSOnlyChan // aka "chan<-" - send only
}

FileChan represents a bidirectional channel

type FileHeaderChan

type FileHeaderChan interface {
	FileHeaderROnlyChan // aka "<-chan" - receive only
	FileHeaderSOnlyChan // aka "chan<-" - send only
}

FileHeaderChan represents a bidirectional channel

type FileHeaderROnlyChan

type FileHeaderROnlyChan interface {
	RequestFileHeader() (dat *zip.FileHeader)        // the receive function - aka "MyFileHeader := <-MyFileHeaderROnlyChan"
	TryFileHeader() (dat *zip.FileHeader, open bool) // the multi-valued comma-ok receive function - aka "MyFileHeader, ok := <-MyFileHeaderROnlyChan"
}

FileHeaderROnlyChan represents a receive-only channel

type FileHeaderSOnlyChan

type FileHeaderSOnlyChan interface {
	ProvideFileHeader(dat *zip.FileHeader) // the send function - aka "MyKind <- some FileHeader"
}

FileHeaderSOnlyChan represents a send-only channel

type FileROnlyChan

type FileROnlyChan interface {
	RequestFile() (dat *zip.File)        // the receive function - aka "MyFile := <-MyFileROnlyChan"
	TryFile() (dat *zip.File, open bool) // the multi-valued comma-ok receive function - aka "MyFile, ok := <-MyFileROnlyChan"
}

FileROnlyChan represents a receive-only channel

type FileSOnlyChan

type FileSOnlyChan interface {
	ProvideFile(dat *zip.File) // the send function - aka "MyKind <- some File"
}

FileSOnlyChan represents a send-only channel

type ReadCloserChan

type ReadCloserChan interface {
	ReadCloserROnlyChan // aka "<-chan" - receive only
	ReadCloserSOnlyChan // aka "chan<-" - send only
}

ReadCloserChan represents a bidirectional channel

type ReadCloserROnlyChan

type ReadCloserROnlyChan interface {
	RequestReadCloser() (dat *zip.ReadCloser)        // the receive function - aka "MyReadCloser := <-MyReadCloserROnlyChan"
	TryReadCloser() (dat *zip.ReadCloser, open bool) // the multi-valued comma-ok receive function - aka "MyReadCloser, ok := <-MyReadCloserROnlyChan"
}

ReadCloserROnlyChan represents a receive-only channel

type ReadCloserSOnlyChan

type ReadCloserSOnlyChan interface {
	ProvideReadCloser(dat *zip.ReadCloser) // the send function - aka "MyKind <- some ReadCloser"
}

ReadCloserSOnlyChan represents a send-only channel

type ReaderChan

type ReaderChan interface {
	ReaderROnlyChan // aka "<-chan" - receive only
	ReaderSOnlyChan // aka "chan<-" - send only
}

ReaderChan represents a bidirectional channel

type ReaderROnlyChan

type ReaderROnlyChan interface {
	RequestReader() (dat *zip.Reader)        // the receive function - aka "MyReader := <-MyReaderROnlyChan"
	TryReader() (dat *zip.Reader, open bool) // the multi-valued comma-ok receive function - aka "MyReader, ok := <-MyReaderROnlyChan"
}

ReaderROnlyChan represents a receive-only channel

type ReaderSOnlyChan

type ReaderSOnlyChan interface {
	ProvideReader(dat *zip.Reader) // the send function - aka "MyKind <- some Reader"
}

ReaderSOnlyChan represents a send-only channel

type WriterChan

type WriterChan interface {
	WriterROnlyChan // aka "<-chan" - receive only
	WriterSOnlyChan // aka "chan<-" - send only
}

WriterChan represents a bidirectional channel

type WriterROnlyChan

type WriterROnlyChan interface {
	RequestWriter() (dat *zip.Writer)        // the receive function - aka "MyWriter := <-MyWriterROnlyChan"
	TryWriter() (dat *zip.Writer, open bool) // the multi-valued comma-ok receive function - aka "MyWriter, ok := <-MyWriterROnlyChan"
}

WriterROnlyChan represents a receive-only channel

type WriterSOnlyChan

type WriterSOnlyChan interface {
	ProvideWriter(dat *zip.Writer) // the send function - aka "MyKind <- some Writer"
}

WriterSOnlyChan represents a send-only channel