zip

Documentation

Index

• 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 SChFile
  • func MakeSupplyFileBuff(cap int) *SChFile
  • func MakeSupplyFileChan() *SChFile
  • func (c *SChFile) ProvideFile(dat *zip.File)
  • func (c *SChFile) RequestFile() (dat *zip.File)
  • func (c *SChFile) TryFile() (dat *zip.File, open bool)
• type SChFileHeader
  • func MakeSupplyFileHeaderBuff(cap int) *SChFileHeader
  • func MakeSupplyFileHeaderChan() *SChFileHeader
  • func (c *SChFileHeader) ProvideFileHeader(dat *zip.FileHeader)
  • func (c *SChFileHeader) RequestFileHeader() (dat *zip.FileHeader)
  • func (c *SChFileHeader) TryFileHeader() (dat *zip.FileHeader, open bool)
• type SChReadCloser
  • func MakeSupplyReadCloserBuff(cap int) *SChReadCloser
  • func MakeSupplyReadCloserChan() *SChReadCloser
  • func (c *SChReadCloser) ProvideReadCloser(dat *zip.ReadCloser)
  • func (c *SChReadCloser) RequestReadCloser() (dat *zip.ReadCloser)
  • func (c *SChReadCloser) TryReadCloser() (dat *zip.ReadCloser, open bool)
• type SChReader
  • func MakeSupplyReaderBuff(cap int) *SChReader
  • func MakeSupplyReaderChan() *SChReader
  • func (c *SChReader) ProvideReader(dat *zip.Reader)
  • func (c *SChReader) RequestReader() (dat *zip.Reader)
  • func (c *SChReader) TryReader() (dat *zip.Reader, open bool)
• type SChWriter
  • func MakeSupplyWriterBuff(cap int) *SChWriter
  • func MakeSupplyWriterChan() *SChWriter
  • func (c *SChWriter) ProvideWriter(dat *zip.Writer)
  • func (c *SChWriter) RequestWriter() (dat *zip.Writer)
  • func (c *SChWriter) TryWriter() (dat *zip.Writer, open bool)
• type WriterChan
• type WriterROnlyChan
• type WriterSOnlyChan

Types

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 SChFile

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

SChFile is a supply channel

func MakeSupplyFileBuff

func MakeSupplyFileBuff(cap int) *SChFile

MakeSupplyFileBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyFileChan

func MakeSupplyFileChan() *SChFile

MakeSupplyFileChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChFile) ProvideFile

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

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

func (*SChFile) RequestFile

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

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

func (*SChFile) TryFile

func (c *SChFile) 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 SChFileHeader

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

SChFileHeader is a supply channel

func MakeSupplyFileHeaderBuff

func MakeSupplyFileHeaderBuff(cap int) *SChFileHeader

MakeSupplyFileHeaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyFileHeaderChan

func MakeSupplyFileHeaderChan() *SChFileHeader

MakeSupplyFileHeaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChFileHeader) ProvideFileHeader

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

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

func (*SChFileHeader) RequestFileHeader

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

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

func (*SChFileHeader) TryFileHeader

func (c *SChFileHeader) 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 SChReadCloser

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

SChReadCloser is a supply channel

func MakeSupplyReadCloserBuff

func MakeSupplyReadCloserBuff(cap int) *SChReadCloser

MakeSupplyReadCloserBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReadCloserChan

func MakeSupplyReadCloserChan() *SChReadCloser

MakeSupplyReadCloserChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReadCloser) ProvideReadCloser

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

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

func (*SChReadCloser) RequestReadCloser

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

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

func (*SChReadCloser) TryReadCloser

func (c *SChReadCloser) 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 SChReader

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

SChReader is a supply channel

func MakeSupplyReaderBuff

func MakeSupplyReaderBuff(cap int) *SChReader

MakeSupplyReaderBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyReaderChan

func MakeSupplyReaderChan() *SChReader

MakeSupplyReaderChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChReader) ProvideReader

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

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

func (*SChReader) RequestReader

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

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

func (*SChReader) TryReader

func (c *SChReader) 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 SChWriter

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

SChWriter is a supply channel

func MakeSupplyWriterBuff

func MakeSupplyWriterBuff(cap int) *SChWriter

MakeSupplyWriterBuff returns a (pointer to a) fresh buffered (with capacity cap) supply channel

func MakeSupplyWriterChan

func MakeSupplyWriterChan() *SChWriter

MakeSupplyWriterChan returns a (pointer to a) fresh unbuffered supply channel

func (*SChWriter) ProvideWriter

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

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

func (*SChWriter) RequestWriter

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

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

func (*SChWriter) TryWriter

func (c *SChWriter) 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 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