test

Documentation

Index

• type DChPointer
  • func MakeDemandPointerBuff(cap int) *DChPointer
  • func MakeDemandPointerChan() *DChPointer
  • func (c *DChPointer) ProvidePointer(dat *SomeType)
  • func (c *DChPointer) RequestPointer() (dat *SomeType)
  • func (c *DChPointer) TryPointer() (dat *SomeType, open bool)
• type DChPointerS
  • func MakeDemandPointerSBuff(cap int) *DChPointerS
  • func MakeDemandPointerSChan() *DChPointerS
  • func (c *DChPointerS) ProvidePointerS(dat []*SomeType)
  • func (c *DChPointerS) RequestPointerS() (dat []*SomeType)
  • func (c *DChPointerS) TryPointerS() (dat []*SomeType, open bool)
• type DChSomeType
  • func MakeDemandSomeTypeBuff(cap int) *DChSomeType
  • func MakeDemandSomeTypeChan() *DChSomeType
  • func (c *DChSomeType) ProvideSomeType(dat SomeType)
  • func (c *DChSomeType) RequestSomeType() (dat SomeType)
  • func (c *DChSomeType) TrySomeType() (dat SomeType, open bool)
• type DChSomeTypeS
  • func MakeDemandSomeTypeSBuff(cap int) *DChSomeTypeS
  • func MakeDemandSomeTypeSChan() *DChSomeTypeS
  • func (c *DChSomeTypeS) ProvideSomeTypeS(dat []SomeType)
  • func (c *DChSomeTypeS) RequestSomeTypeS() (dat []SomeType)
  • func (c *DChSomeTypeS) TrySomeTypeS() (dat []SomeType, open bool)
• type PointerChan
• type PointerROnlyChan
• type PointerSChan
• type PointerSOnlyChan
• type PointerSROnlyChan
• type PointerSSOnlyChan
• type SomeType
• type SomeTypeChan
• type SomeTypeROnlyChan
• type SomeTypeSChan
• type SomeTypeSOnlyChan
• type SomeTypeSROnlyChan
• type SomeTypeSSOnlyChan

Types

type DChPointer

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

DChPointer is a demand channel

func MakeDemandPointerBuff

func MakeDemandPointerBuff(cap int) *DChPointer

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

func MakeDemandPointerChan

func MakeDemandPointerChan() *DChPointer

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

func (*DChPointer) ProvidePointer

func (c *DChPointer) ProvidePointer(dat *SomeType)

ProvidePointer is the send function - aka "MyKind <- some Pointer"

func (*DChPointer) RequestPointer

func (c *DChPointer) RequestPointer() (dat *SomeType)

RequestPointer is the receive function - aka "some Pointer <- MyKind"

func (*DChPointer) TryPointer

func (c *DChPointer) TryPointer() (dat *SomeType, open bool)

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

type DChPointerS

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

DChPointerS is a demand channel

func MakeDemandPointerSBuff

func MakeDemandPointerSBuff(cap int) *DChPointerS

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

func MakeDemandPointerSChan

func MakeDemandPointerSChan() *DChPointerS

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

func (*DChPointerS) ProvidePointerS

func (c *DChPointerS) ProvidePointerS(dat []*SomeType)

ProvidePointerS is the send function - aka "MyKind <- some PointerS"

func (*DChPointerS) RequestPointerS

func (c *DChPointerS) RequestPointerS() (dat []*SomeType)

RequestPointerS is the receive function - aka "some PointerS <- MyKind"

func (*DChPointerS) TryPointerS

func (c *DChPointerS) TryPointerS() (dat []*SomeType, open bool)

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

type DChSomeType

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

DChSomeType is a demand channel

func MakeDemandSomeTypeBuff

func MakeDemandSomeTypeBuff(cap int) *DChSomeType

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

func MakeDemandSomeTypeChan

func MakeDemandSomeTypeChan() *DChSomeType

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

func (*DChSomeType) ProvideSomeType

func (c *DChSomeType) ProvideSomeType(dat SomeType)

ProvideSomeType is the send function - aka "MyKind <- some SomeType"

func (*DChSomeType) RequestSomeType

func (c *DChSomeType) RequestSomeType() (dat SomeType)

RequestSomeType is the receive function - aka "some SomeType <- MyKind"

func (*DChSomeType) TrySomeType

func (c *DChSomeType) TrySomeType() (dat SomeType, open bool)

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

type DChSomeTypeS

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

DChSomeTypeS is a demand channel

func MakeDemandSomeTypeSBuff

func MakeDemandSomeTypeSBuff(cap int) *DChSomeTypeS

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

func MakeDemandSomeTypeSChan

func MakeDemandSomeTypeSChan() *DChSomeTypeS

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

func (*DChSomeTypeS) ProvideSomeTypeS

func (c *DChSomeTypeS) ProvideSomeTypeS(dat []SomeType)

ProvideSomeTypeS is the send function - aka "MyKind <- some SomeTypeS"

func (*DChSomeTypeS) RequestSomeTypeS

func (c *DChSomeTypeS) RequestSomeTypeS() (dat []SomeType)

RequestSomeTypeS is the receive function - aka "some SomeTypeS <- MyKind"

func (*DChSomeTypeS) TrySomeTypeS

func (c *DChSomeTypeS) TrySomeTypeS() (dat []SomeType, open bool)

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

type PointerChan

type PointerChan interface {
	PointerROnlyChan // aka "<-chan" - receive only
	PointerSOnlyChan // aka "chan<-" - send only
}

PointerChan represents a bidirectional channel

type PointerROnlyChan

type PointerROnlyChan interface {
	RequestPointer() (dat *SomeType)        // the receive function - aka "MyPointer := <-MyPointerROnlyChan"
	TryPointer() (dat *SomeType, open bool) // the multi-valued comma-ok receive function - aka "MyPointer, ok := <-MyPointerROnlyChan"
}

PointerROnlyChan represents a receive-only channel

type PointerSChan

type PointerSChan interface {
	PointerSROnlyChan // aka "<-chan" - receive only
	PointerSSOnlyChan // aka "chan<-" - send only
}

PointerSChan represents a bidirectional channel

type PointerSOnlyChan

type PointerSOnlyChan interface {
	ProvidePointer(dat *SomeType) // the send function - aka "MyKind <- some Pointer"
}

PointerSOnlyChan represents a send-only channel

type PointerSROnlyChan

type PointerSROnlyChan interface {
	RequestPointerS() (dat []*SomeType)        // the receive function - aka "MyPointerS := <-MyPointerSROnlyChan"
	TryPointerS() (dat []*SomeType, open bool) // the multi-valued comma-ok receive function - aka "MyPointerS, ok := <-MyPointerSROnlyChan"
}

PointerSROnlyChan represents a receive-only channel

type PointerSSOnlyChan

type PointerSSOnlyChan interface {
	ProvidePointerS(dat []*SomeType) // the send function - aka "MyKind <- some PointerS"
}

PointerSSOnlyChan represents a send-only channel

type SomeType

type SomeType string

SomeType is some type and just represents a string.

type SomeTypeChan

type SomeTypeChan interface {
	SomeTypeROnlyChan // aka "<-chan" - receive only
	SomeTypeSOnlyChan // aka "chan<-" - send only
}

SomeTypeChan represents a bidirectional channel

type SomeTypeROnlyChan

type SomeTypeROnlyChan interface {
	RequestSomeType() (dat SomeType)        // the receive function - aka "MySomeType := <-MySomeTypeROnlyChan"
	TrySomeType() (dat SomeType, open bool) // the multi-valued comma-ok receive function - aka "MySomeType, ok := <-MySomeTypeROnlyChan"
}

SomeTypeROnlyChan represents a receive-only channel

type SomeTypeSChan

type SomeTypeSChan interface {
	SomeTypeSROnlyChan // aka "<-chan" - receive only
	SomeTypeSSOnlyChan // aka "chan<-" - send only
}

SomeTypeSChan represents a bidirectional channel

type SomeTypeSOnlyChan

type SomeTypeSOnlyChan interface {
	ProvideSomeType(dat SomeType) // the send function - aka "MyKind <- some SomeType"
}

SomeTypeSOnlyChan represents a send-only channel

type SomeTypeSROnlyChan

type SomeTypeSROnlyChan interface {
	RequestSomeTypeS() (dat []SomeType)        // the receive function - aka "MySomeTypeS := <-MySomeTypeSROnlyChan"
	TrySomeTypeS() (dat []SomeType, open bool) // the multi-valued comma-ok receive function - aka "MySomeTypeS, ok := <-MySomeTypeSROnlyChan"
}

SomeTypeSROnlyChan represents a receive-only channel

type SomeTypeSSOnlyChan

type SomeTypeSSOnlyChan interface {
	ProvideSomeTypeS(dat []SomeType) // the send function - aka "MyKind <- some SomeTypeS"
}

SomeTypeSSOnlyChan represents a send-only channel