IsByte

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

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BufferChan 

type BufferChan interface {
	BufferROnlyChan // aka "<-chan" - receive only
	BufferSOnlyChan // aka "chan<-" - send only
}

BufferChan represents a bidirectional channel

type BufferROnlyChan 

type BufferROnlyChan interface {
	RequestBuffer() (dat bytes.Buffer)        // the receive function - aka "MyBuffer := <-MyBufferROnlyChan"
	TryBuffer() (dat bytes.Buffer, open bool) // the multi-valued comma-ok receive function - aka "MyBuffer, ok := <-MyBufferROnlyChan"
}

BufferROnlyChan represents a receive-only channel

type BufferSOnlyChan 

type BufferSOnlyChan interface {
	ProvideBuffer(dat bytes.Buffer) // the send function - aka "MyKind <- some Buffer"
}

BufferSOnlyChan represents a send-only channel

type ByteChan 

type ByteChan interface {
	ByteROnlyChan // aka "<-chan" - receive only
	ByteSOnlyChan // aka "chan<-" - send only
}

ByteChan represents a bidirectional channel

type ByteROnlyChan 

type ByteROnlyChan interface {
	RequestByte() (dat byte)        // the receive function - aka "MyByte := <-MyByteROnlyChan"
	TryByte() (dat byte, open bool) // the multi-valued comma-ok receive function - aka "MyByte, ok := <-MyByteROnlyChan"
}

ByteROnlyChan represents a receive-only channel

type ByteReaderChan 

type ByteReaderChan interface {
	ByteReaderROnlyChan // aka "<-chan" - receive only
	ByteReaderSOnlyChan // aka "chan<-" - send only
}

ByteReaderChan represents a bidirectional channel

type ByteReaderROnlyChan 

type ByteReaderROnlyChan interface {
	RequestByteReader() (dat io.ByteReader)        // the receive function - aka "MyByteReader := <-MyByteReaderROnlyChan"
	TryByteReader() (dat io.ByteReader, open bool) // the multi-valued comma-ok receive function - aka "MyByteReader, ok := <-MyByteReaderROnlyChan"
}

ByteReaderROnlyChan represents a receive-only channel

type ByteReaderSOnlyChan 

type ByteReaderSOnlyChan interface {
	ProvideByteReader(dat io.ByteReader) // the send function - aka "MyKind <- some ByteReader"
}

ByteReaderSOnlyChan represents a send-only channel

type ByteSOnlyChan 

type ByteSOnlyChan interface {
	ProvideByte(dat byte) // the send function - aka "MyKind <- some Byte"
}

ByteSOnlyChan represents a send-only channel

type ByteScannerChan 

type ByteScannerChan interface {
	ByteScannerROnlyChan // aka "<-chan" - receive only
	ByteScannerSOnlyChan // aka "chan<-" - send only
}

ByteScannerChan represents a bidirectional channel

type ByteScannerROnlyChan 

type ByteScannerROnlyChan interface {
	RequestByteScanner() (dat io.ByteScanner)        // the receive function - aka "MyByteScanner := <-MyByteScannerROnlyChan"
	TryByteScanner() (dat io.ByteScanner, open bool) // the multi-valued comma-ok receive function - aka "MyByteScanner, ok := <-MyByteScannerROnlyChan"
}

ByteScannerROnlyChan represents a receive-only channel

type ByteScannerSOnlyChan 

type ByteScannerSOnlyChan interface {
	ProvideByteScanner(dat io.ByteScanner) // the send function - aka "MyKind <- some ByteScanner"
}

ByteScannerSOnlyChan represents a send-only channel

type ByteWriterChan 

type ByteWriterChan interface {
	ByteWriterROnlyChan // aka "<-chan" - receive only
	ByteWriterSOnlyChan // aka "chan<-" - send only
}

ByteWriterChan represents a bidirectional channel

type ByteWriterROnlyChan 

type ByteWriterROnlyChan interface {
	RequestByteWriter() (dat io.ByteWriter)        // the receive function - aka "MyByteWriter := <-MyByteWriterROnlyChan"
	TryByteWriter() (dat io.ByteWriter, open bool) // the multi-valued comma-ok receive function - aka "MyByteWriter, ok := <-MyByteWriterROnlyChan"
}

ByteWriterROnlyChan represents a receive-only channel

type ByteWriterSOnlyChan 

type ByteWriterSOnlyChan interface {
	ProvideByteWriter(dat io.ByteWriter) // the send function - aka "MyKind <- some ByteWriter"
}

ByteWriterSOnlyChan represents a send-only channel

type Chan 

type Chan interface {
	ROnlyChan // aka "<-chan" - receive only
	SOnlyChan // aka "chan<-" - send only
}

Chan represents a bidirectional channel

type DCh 

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

DCh is a demand channel

func MakeDemandBuff 

func MakeDemandBuff(cap int) *DCh

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

func MakeDemandChan 

func MakeDemandChan() *DCh

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

func (*DCh) Provide 

func (c *DCh) Provide(dat []byte)

Provide is the send function - aka "MyKind <- some "

func (*DCh) Request 

func (c *DCh) Request() (dat []byte)

Request is the receive function - aka "some <- MyKind"

func (*DCh) Try 

func (c *DCh) Try() (dat []byte, open bool)

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

type DChBuffer 

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

DChBuffer is a demand channel

func MakeDemandBufferBuff 

func MakeDemandBufferBuff(cap int) *DChBuffer

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

func MakeDemandBufferChan 

func MakeDemandBufferChan() *DChBuffer

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

func (*DChBuffer) ProvideBuffer 

func (c *DChBuffer) ProvideBuffer(dat bytes.Buffer)

ProvideBuffer is the send function - aka "MyKind <- some Buffer"

func (*DChBuffer) RequestBuffer 

func (c *DChBuffer) RequestBuffer() (dat bytes.Buffer)

RequestBuffer is the receive function - aka "some Buffer <- MyKind"

func (*DChBuffer) TryBuffer 

func (c *DChBuffer) TryBuffer() (dat bytes.Buffer, open bool)

TryBuffer is the comma-ok multi-valued form of RequestBuffer and reports whether a received value was sent before the Buffer channel was closed.

type DChByte 

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

DChByte is a demand channel

func MakeDemandByteBuff 

func MakeDemandByteBuff(cap int) *DChByte

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

func MakeDemandByteChan 

func MakeDemandByteChan() *DChByte

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

func (*DChByte) ProvideByte 

func (c *DChByte) ProvideByte(dat byte)

ProvideByte is the send function - aka "MyKind <- some Byte"

func (*DChByte) RequestByte 

func (c *DChByte) RequestByte() (dat byte)

RequestByte is the receive function - aka "some Byte <- MyKind"

func (*DChByte) TryByte 

func (c *DChByte) TryByte() (dat byte, open bool)

TryByte is the comma-ok multi-valued form of RequestByte and reports whether a received value was sent before the Byte channel was closed.

type DChByteReader 

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

DChByteReader is a demand channel

func MakeDemandByteReaderBuff 

func MakeDemandByteReaderBuff(cap int) *DChByteReader

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

func MakeDemandByteReaderChan 

func MakeDemandByteReaderChan() *DChByteReader

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

func (*DChByteReader) ProvideByteReader 

func (c *DChByteReader) ProvideByteReader(dat io.ByteReader)

ProvideByteReader is the send function - aka "MyKind <- some ByteReader"

func (*DChByteReader) RequestByteReader 

func (c *DChByteReader) RequestByteReader() (dat io.ByteReader)

RequestByteReader is the receive function - aka "some ByteReader <- MyKind"

func (*DChByteReader) TryByteReader 

func (c *DChByteReader) TryByteReader() (dat io.ByteReader, open bool)

TryByteReader is the comma-ok multi-valued form of RequestByteReader and reports whether a received value was sent before the ByteReader channel was closed.

type DChByteScanner 

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

DChByteScanner is a demand channel

func MakeDemandByteScannerBuff 

func MakeDemandByteScannerBuff(cap int) *DChByteScanner

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

func MakeDemandByteScannerChan 

func MakeDemandByteScannerChan() *DChByteScanner

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

func (*DChByteScanner) ProvideByteScanner 

func (c *DChByteScanner) ProvideByteScanner(dat io.ByteScanner)

ProvideByteScanner is the send function - aka "MyKind <- some ByteScanner"

func (*DChByteScanner) RequestByteScanner 

func (c *DChByteScanner) RequestByteScanner() (dat io.ByteScanner)

RequestByteScanner is the receive function - aka "some ByteScanner <- MyKind"

func (*DChByteScanner) TryByteScanner 

func (c *DChByteScanner) TryByteScanner() (dat io.ByteScanner, open bool)

TryByteScanner is the comma-ok multi-valued form of RequestByteScanner and reports whether a received value was sent before the ByteScanner channel was closed.

type DChByteWriter 

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

DChByteWriter is a demand channel

func MakeDemandByteWriterBuff 

func MakeDemandByteWriterBuff(cap int) *DChByteWriter

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

func MakeDemandByteWriterChan 

func MakeDemandByteWriterChan() *DChByteWriter

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

func (*DChByteWriter) ProvideByteWriter 

func (c *DChByteWriter) ProvideByteWriter(dat io.ByteWriter)

ProvideByteWriter is the send function - aka "MyKind <- some ByteWriter"

func (*DChByteWriter) RequestByteWriter 

func (c *DChByteWriter) RequestByteWriter() (dat io.ByteWriter)

RequestByteWriter is the receive function - aka "some ByteWriter <- MyKind"

func (*DChByteWriter) TryByteWriter 

func (c *DChByteWriter) TryByteWriter() (dat io.ByteWriter, open bool)

TryByteWriter is the comma-ok multi-valued form of RequestByteWriter and reports whether a received value was sent before the ByteWriter 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 bytes.Reader)

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

func (*DChReader) RequestReader 

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

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

func (*DChReader) TryReader 

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

type ROnlyChan interface {
	Request() (dat []byte)        // the receive function - aka "My := <-MyROnlyChan"
	Try() (dat []byte, open bool) // the multi-valued comma-ok receive function - aka "My, ok := <-MyROnlyChan"
}

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

ReaderSOnlyChan represents a send-only channel

type SCh 

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

SCh is a supply channel

func MakeSupplyBuff 

func MakeSupplyBuff(cap int) *SCh

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

func MakeSupplyChan 

func MakeSupplyChan() *SCh

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

func (*SCh) Provide 

func (c *SCh) Provide(dat []byte)

Provide is the send function - aka "MyKind <- some "

func (*SCh) Request 

func (c *SCh) Request() (dat []byte)

Request is the receive function - aka "some <- MyKind"

func (*SCh) Try 

func (c *SCh) Try() (dat []byte, open bool)

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

type SChBuffer 

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

SChBuffer is a supply channel

func MakeSupplyBufferBuff 

func MakeSupplyBufferBuff(cap int) *SChBuffer

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

func MakeSupplyBufferChan 

func MakeSupplyBufferChan() *SChBuffer

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

func (*SChBuffer) ProvideBuffer 

func (c *SChBuffer) ProvideBuffer(dat bytes.Buffer)

ProvideBuffer is the send function - aka "MyKind <- some Buffer"

func (*SChBuffer) RequestBuffer 

func (c *SChBuffer) RequestBuffer() (dat bytes.Buffer)

RequestBuffer is the receive function - aka "some Buffer <- MyKind"

func (*SChBuffer) TryBuffer 

func (c *SChBuffer) TryBuffer() (dat bytes.Buffer, open bool)

TryBuffer is the comma-ok multi-valued form of RequestBuffer and reports whether a received value was sent before the Buffer channel was closed.

type SChByte 

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

SChByte is a supply channel

func MakeSupplyByteBuff 

func MakeSupplyByteBuff(cap int) *SChByte

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

func MakeSupplyByteChan 

func MakeSupplyByteChan() *SChByte

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

func (*SChByte) ProvideByte 

func (c *SChByte) ProvideByte(dat byte)

ProvideByte is the send function - aka "MyKind <- some Byte"

func (*SChByte) RequestByte 

func (c *SChByte) RequestByte() (dat byte)

RequestByte is the receive function - aka "some Byte <- MyKind"

func (*SChByte) TryByte 

func (c *SChByte) TryByte() (dat byte, open bool)

TryByte is the comma-ok multi-valued form of RequestByte and reports whether a received value was sent before the Byte channel was closed.

type SChByteReader 

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

SChByteReader is a supply channel

func MakeSupplyByteReaderBuff 

func MakeSupplyByteReaderBuff(cap int) *SChByteReader

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

func MakeSupplyByteReaderChan 

func MakeSupplyByteReaderChan() *SChByteReader

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

func (*SChByteReader) ProvideByteReader 

func (c *SChByteReader) ProvideByteReader(dat io.ByteReader)

ProvideByteReader is the send function - aka "MyKind <- some ByteReader"

func (*SChByteReader) RequestByteReader 

func (c *SChByteReader) RequestByteReader() (dat io.ByteReader)

RequestByteReader is the receive function - aka "some ByteReader <- MyKind"

func (*SChByteReader) TryByteReader 

func (c *SChByteReader) TryByteReader() (dat io.ByteReader, open bool)

TryByteReader is the comma-ok multi-valued form of RequestByteReader and reports whether a received value was sent before the ByteReader channel was closed.

type SChByteScanner 

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

SChByteScanner is a supply channel

func MakeSupplyByteScannerBuff 

func MakeSupplyByteScannerBuff(cap int) *SChByteScanner

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

func MakeSupplyByteScannerChan 

func MakeSupplyByteScannerChan() *SChByteScanner

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

func (*SChByteScanner) ProvideByteScanner 

func (c *SChByteScanner) ProvideByteScanner(dat io.ByteScanner)

ProvideByteScanner is the send function - aka "MyKind <- some ByteScanner"

func (*SChByteScanner) RequestByteScanner 

func (c *SChByteScanner) RequestByteScanner() (dat io.ByteScanner)

RequestByteScanner is the receive function - aka "some ByteScanner <- MyKind"

func (*SChByteScanner) TryByteScanner 

func (c *SChByteScanner) TryByteScanner() (dat io.ByteScanner, open bool)

TryByteScanner is the comma-ok multi-valued form of RequestByteScanner and reports whether a received value was sent before the ByteScanner channel was closed.

type SChByteWriter 

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

SChByteWriter is a supply channel

func MakeSupplyByteWriterBuff 

func MakeSupplyByteWriterBuff(cap int) *SChByteWriter

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

func MakeSupplyByteWriterChan 

func MakeSupplyByteWriterChan() *SChByteWriter

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

func (*SChByteWriter) ProvideByteWriter 

func (c *SChByteWriter) ProvideByteWriter(dat io.ByteWriter)

ProvideByteWriter is the send function - aka "MyKind <- some ByteWriter"

func (*SChByteWriter) RequestByteWriter 

func (c *SChByteWriter) RequestByteWriter() (dat io.ByteWriter)

RequestByteWriter is the receive function - aka "some ByteWriter <- MyKind"

func (*SChByteWriter) TryByteWriter 

func (c *SChByteWriter) TryByteWriter() (dat io.ByteWriter, open bool)

TryByteWriter is the comma-ok multi-valued form of RequestByteWriter and reports whether a received value was sent before the ByteWriter 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 bytes.Reader)

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

func (*SChReader) RequestReader 

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

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

func (*SChReader) TryReader 

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

type SOnlyChan interface {
	Provide(dat []byte) // the send function - aka "MyKind <- some "
}

SOnlyChan represents a send-only channel

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.