tar

Documentation

Index

• type DChHeader
  • func MakeDemandHeaderBuff(cap int) *DChHeader
  • func MakeDemandHeaderChan() *DChHeader
  • func (c *DChHeader) ProvideHeader(dat *tar.Header)
  • func (c *DChHeader) RequestHeader() (dat *tar.Header)
  • func (c *DChHeader) TryHeader() (dat *tar.Header, open bool)
• type DChReader
  • func MakeDemandReaderBuff(cap int) *DChReader
  • func MakeDemandReaderChan() *DChReader
  • func (c *DChReader) ProvideReader(dat *tar.Reader)
  • func (c *DChReader) RequestReader() (dat *tar.Reader)
  • func (c *DChReader) TryReader() (dat *tar.Reader, open bool)
• type DChWriter
  • func MakeDemandWriterBuff(cap int) *DChWriter
  • func MakeDemandWriterChan() *DChWriter
  • func (c *DChWriter) ProvideWriter(dat *tar.Writer)
  • func (c *DChWriter) RequestWriter() (dat *tar.Writer)
  • func (c *DChWriter) TryWriter() (dat *tar.Writer, open bool)
• type HeaderChan
• type HeaderROnlyChan
• type HeaderSOnlyChan
• type ReaderChan
• type ReaderROnlyChan
• type ReaderSOnlyChan
• type SChHeader
  • func MakeSupplyHeaderBuff(cap int) *SChHeader
  • func MakeSupplyHeaderChan() *SChHeader
  • func (c *SChHeader) ProvideHeader(dat *tar.Header)
  • func (c *SChHeader) RequestHeader() (dat *tar.Header)
  • func (c *SChHeader) TryHeader() (dat *tar.Header, open bool)
• type SChReader
  • func MakeSupplyReaderBuff(cap int) *SChReader
  • func MakeSupplyReaderChan() *SChReader
  • func (c *SChReader) ProvideReader(dat *tar.Reader)
  • func (c *SChReader) RequestReader() (dat *tar.Reader)
  • func (c *SChReader) TryReader() (dat *tar.Reader, open bool)
• type SChWriter
  • func MakeSupplyWriterBuff(cap int) *SChWriter
  • func MakeSupplyWriterChan() *SChWriter
  • func (c *SChWriter) ProvideWriter(dat *tar.Writer)
  • func (c *SChWriter) RequestWriter() (dat *tar.Writer)
  • func (c *SChWriter) TryWriter() (dat *tar.Writer, open bool)
• type WriterChan
• type WriterROnlyChan
• type WriterSOnlyChan

Types

type DChHeader

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

DChHeader is a demand channel

func MakeDemandHeaderBuff

func MakeDemandHeaderBuff(cap int) *DChHeader

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

func MakeDemandHeaderChan

func MakeDemandHeaderChan() *DChHeader

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

func (*DChHeader) ProvideHeader

func (c *DChHeader) ProvideHeader(dat *tar.Header)

ProvideHeader is the send function - aka "MyKind <- some Header"

func (*DChHeader) RequestHeader

func (c *DChHeader) RequestHeader() (dat *tar.Header)

RequestHeader is the receive function - aka "some Header <- MyKind"

func (*DChHeader) TryHeader

func (c *DChHeader) TryHeader() (dat *tar.Header, open bool)

TryHeader is the comma-ok multi-valued form of RequestHeader and reports whether a received value was sent before the Header 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 *tar.Reader)

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

func (*DChReader) RequestReader

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

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

func (*DChReader) TryReader

func (c *DChReader) TryReader() (dat *tar.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 *tar.Writer)

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

func (*DChWriter) RequestWriter

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

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

func (*DChWriter) TryWriter

func (c *DChWriter) TryWriter() (dat *tar.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 HeaderChan

type HeaderChan interface {
	HeaderROnlyChan // aka "<-chan" - receive only
	HeaderSOnlyChan // aka "chan<-" - send only
}

HeaderChan represents a bidirectional channel

type HeaderROnlyChan

type HeaderROnlyChan interface {
	RequestHeader() (dat *tar.Header)        // the receive function - aka "MyHeader := <-MyHeaderROnlyChan"
	TryHeader() (dat *tar.Header, open bool) // the multi-valued comma-ok receive function - aka "MyHeader, ok := <-MyHeaderROnlyChan"
}

HeaderROnlyChan represents a receive-only channel

type HeaderSOnlyChan

type HeaderSOnlyChan interface {
	ProvideHeader(dat *tar.Header) // the send function - aka "MyKind <- some Header"
}

HeaderSOnlyChan 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 *tar.Reader)        // the receive function - aka "MyReader := <-MyReaderROnlyChan"
	TryReader() (dat *tar.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 *tar.Reader) // the send function - aka "MyKind <- some Reader"
}

ReaderSOnlyChan represents a send-only channel

type SChHeader

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

SChHeader is a supply channel

func MakeSupplyHeaderBuff

func MakeSupplyHeaderBuff(cap int) *SChHeader

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

func MakeSupplyHeaderChan

func MakeSupplyHeaderChan() *SChHeader

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

func (*SChHeader) ProvideHeader

func (c *SChHeader) ProvideHeader(dat *tar.Header)

ProvideHeader is the send function - aka "MyKind <- some Header"

func (*SChHeader) RequestHeader

func (c *SChHeader) RequestHeader() (dat *tar.Header)

RequestHeader is the receive function - aka "some Header <- MyKind"

func (*SChHeader) TryHeader

func (c *SChHeader) TryHeader() (dat *tar.Header, open bool)

TryHeader is the comma-ok multi-valued form of RequestHeader and reports whether a received value was sent before the Header 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 *tar.Reader)

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

func (*SChReader) RequestReader

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

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

func (*SChReader) TryReader

func (c *SChReader) TryReader() (dat *tar.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 *tar.Writer)

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

func (*SChWriter) RequestWriter

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

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

func (*SChWriter) TryWriter

func (c *SChWriter) TryWriter() (dat *tar.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 *tar.Writer)        // the receive function - aka "MyWriter := <-MyWriterROnlyChan"
	TryWriter() (dat *tar.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 *tar.Writer) // the send function - aka "MyKind <- some Writer"
}

WriterSOnlyChan represents a send-only channel