IsUnsigned

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: 0 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BasicInfo 

type BasicInfo int

BasicInfo is a set of flags describing properties of a basic type. 

const (
	IsBoolean BasicInfo = 1 << iota
	IsInteger
	IsUnsigned
	IsFloat
	IsComplex
	IsString
	IsUntyped

	IsOrdered   = IsInteger | IsFloat | IsString
	IsNumeric   = IsInteger | IsFloat | IsComplex
	IsConstType = IsBoolean | IsNumeric | IsString
)

Properties of basic types.

type BasicKind 

type BasicKind int

BasicKind describes the kind of basic type.

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 uint)

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

func (*DCh) Request 

func (c *DCh) Request() (dat uint)

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

func (*DCh) Try 

func (c *DCh) Try() (dat uint, 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 DChUInt16 

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

DChUInt16 is a demand channel

func MakeDemandUInt16Buff 

func MakeDemandUInt16Buff(cap int) *DChUInt16

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

func MakeDemandUInt16Chan 

func MakeDemandUInt16Chan() *DChUInt16

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

func (*DChUInt16) ProvideUInt16 

func (c *DChUInt16) ProvideUInt16(dat uint16)

ProvideUInt16 is the send function - aka "MyKind <- some UInt16"

func (*DChUInt16) RequestUInt16 

func (c *DChUInt16) RequestUInt16() (dat uint16)

RequestUInt16 is the receive function - aka "some UInt16 <- MyKind"

func (*DChUInt16) TryUInt16 

func (c *DChUInt16) TryUInt16() (dat uint16, open bool)

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

type DChUInt32 

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

DChUInt32 is a demand channel

func MakeDemandUInt32Buff 

func MakeDemandUInt32Buff(cap int) *DChUInt32

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

func MakeDemandUInt32Chan 

func MakeDemandUInt32Chan() *DChUInt32

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

func (*DChUInt32) ProvideUInt32 

func (c *DChUInt32) ProvideUInt32(dat uint32)

ProvideUInt32 is the send function - aka "MyKind <- some UInt32"

func (*DChUInt32) RequestUInt32 

func (c *DChUInt32) RequestUInt32() (dat uint32)

RequestUInt32 is the receive function - aka "some UInt32 <- MyKind"

func (*DChUInt32) TryUInt32 

func (c *DChUInt32) TryUInt32() (dat uint32, open bool)

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

type DChUInt64 

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

DChUInt64 is a demand channel

func MakeDemandUInt64Buff 

func MakeDemandUInt64Buff(cap int) *DChUInt64

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

func MakeDemandUInt64Chan 

func MakeDemandUInt64Chan() *DChUInt64

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

func (*DChUInt64) ProvideUInt64 

func (c *DChUInt64) ProvideUInt64(dat uint64)

ProvideUInt64 is the send function - aka "MyKind <- some UInt64"

func (*DChUInt64) RequestUInt64 

func (c *DChUInt64) RequestUInt64() (dat uint64)

RequestUInt64 is the receive function - aka "some UInt64 <- MyKind"

func (*DChUInt64) TryUInt64 

func (c *DChUInt64) TryUInt64() (dat uint64, open bool)

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

type DChUInt8 

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

DChUInt8 is a demand channel

func MakeDemandUInt8Buff 

func MakeDemandUInt8Buff(cap int) *DChUInt8

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

func MakeDemandUInt8Chan 

func MakeDemandUInt8Chan() *DChUInt8

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

func (*DChUInt8) ProvideUInt8 

func (c *DChUInt8) ProvideUInt8(dat uint8)

ProvideUInt8 is the send function - aka "MyKind <- some UInt8"

func (*DChUInt8) RequestUInt8 

func (c *DChUInt8) RequestUInt8() (dat uint8)

RequestUInt8 is the receive function - aka "some UInt8 <- MyKind"

func (*DChUInt8) TryUInt8 

func (c *DChUInt8) TryUInt8() (dat uint8, open bool)

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

type ROnlyChan 

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

ROnlyChan represents a receive-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 uint)

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

func (*SCh) Request 

func (c *SCh) Request() (dat uint)

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

func (*SCh) Try 

func (c *SCh) Try() (dat uint, 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 SChUInt16 

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

SChUInt16 is a supply channel

func MakeSupplyUInt16Buff 

func MakeSupplyUInt16Buff(cap int) *SChUInt16

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

func MakeSupplyUInt16Chan 

func MakeSupplyUInt16Chan() *SChUInt16

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

func (*SChUInt16) ProvideUInt16 

func (c *SChUInt16) ProvideUInt16(dat uint16)

ProvideUInt16 is the send function - aka "MyKind <- some UInt16"

func (*SChUInt16) RequestUInt16 

func (c *SChUInt16) RequestUInt16() (dat uint16)

RequestUInt16 is the receive function - aka "some UInt16 <- MyKind"

func (*SChUInt16) TryUInt16 

func (c *SChUInt16) TryUInt16() (dat uint16, open bool)

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

type SChUInt32 

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

SChUInt32 is a supply channel

func MakeSupplyUInt32Buff 

func MakeSupplyUInt32Buff(cap int) *SChUInt32

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

func MakeSupplyUInt32Chan 

func MakeSupplyUInt32Chan() *SChUInt32

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

func (*SChUInt32) ProvideUInt32 

func (c *SChUInt32) ProvideUInt32(dat uint32)

ProvideUInt32 is the send function - aka "MyKind <- some UInt32"

func (*SChUInt32) RequestUInt32 

func (c *SChUInt32) RequestUInt32() (dat uint32)

RequestUInt32 is the receive function - aka "some UInt32 <- MyKind"

func (*SChUInt32) TryUInt32 

func (c *SChUInt32) TryUInt32() (dat uint32, open bool)

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

type SChUInt64 

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

SChUInt64 is a supply channel

func MakeSupplyUInt64Buff 

func MakeSupplyUInt64Buff(cap int) *SChUInt64

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

func MakeSupplyUInt64Chan 

func MakeSupplyUInt64Chan() *SChUInt64

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

func (*SChUInt64) ProvideUInt64 

func (c *SChUInt64) ProvideUInt64(dat uint64)

ProvideUInt64 is the send function - aka "MyKind <- some UInt64"

func (*SChUInt64) RequestUInt64 

func (c *SChUInt64) RequestUInt64() (dat uint64)

RequestUInt64 is the receive function - aka "some UInt64 <- MyKind"

func (*SChUInt64) TryUInt64 

func (c *SChUInt64) TryUInt64() (dat uint64, open bool)

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

type SChUInt8 

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

SChUInt8 is a supply channel

func MakeSupplyUInt8Buff 

func MakeSupplyUInt8Buff(cap int) *SChUInt8

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

func MakeSupplyUInt8Chan 

func MakeSupplyUInt8Chan() *SChUInt8

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

func (*SChUInt8) ProvideUInt8 

func (c *SChUInt8) ProvideUInt8(dat uint8)

ProvideUInt8 is the send function - aka "MyKind <- some UInt8"

func (*SChUInt8) RequestUInt8 

func (c *SChUInt8) RequestUInt8() (dat uint8)

RequestUInt8 is the receive function - aka "some UInt8 <- MyKind"

func (*SChUInt8) TryUInt8 

func (c *SChUInt8) TryUInt8() (dat uint8, open bool)

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

type SOnlyChan 

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

SOnlyChan represents a send-only channel

type UInt16Chan 

type UInt16Chan interface {
	UInt16ROnlyChan // aka "<-chan" - receive only
	UInt16SOnlyChan // aka "chan<-" - send only
}

UInt16Chan represents a bidirectional channel

type UInt16ROnlyChan 

type UInt16ROnlyChan interface {
	RequestUInt16() (dat uint16)        // the receive function - aka "MyUInt16 := <-MyUInt16ROnlyChan"
	TryUInt16() (dat uint16, open bool) // the multi-valued comma-ok receive function - aka "MyUInt16, ok := <-MyUInt16ROnlyChan"
}

UInt16ROnlyChan represents a receive-only channel

type UInt16SOnlyChan 

type UInt16SOnlyChan interface {
	ProvideUInt16(dat uint16) // the send function - aka "MyKind <- some UInt16"
}

UInt16SOnlyChan represents a send-only channel

type UInt32Chan 

type UInt32Chan interface {
	UInt32ROnlyChan // aka "<-chan" - receive only
	UInt32SOnlyChan // aka "chan<-" - send only
}

UInt32Chan represents a bidirectional channel

type UInt32ROnlyChan 

type UInt32ROnlyChan interface {
	RequestUInt32() (dat uint32)        // the receive function - aka "MyUInt32 := <-MyUInt32ROnlyChan"
	TryUInt32() (dat uint32, open bool) // the multi-valued comma-ok receive function - aka "MyUInt32, ok := <-MyUInt32ROnlyChan"
}

UInt32ROnlyChan represents a receive-only channel

type UInt32SOnlyChan 

type UInt32SOnlyChan interface {
	ProvideUInt32(dat uint32) // the send function - aka "MyKind <- some UInt32"
}

UInt32SOnlyChan represents a send-only channel

type UInt64Chan 

type UInt64Chan interface {
	UInt64ROnlyChan // aka "<-chan" - receive only
	UInt64SOnlyChan // aka "chan<-" - send only
}

UInt64Chan represents a bidirectional channel

type UInt64ROnlyChan 

type UInt64ROnlyChan interface {
	RequestUInt64() (dat uint64)        // the receive function - aka "MyUInt64 := <-MyUInt64ROnlyChan"
	TryUInt64() (dat uint64, open bool) // the multi-valued comma-ok receive function - aka "MyUInt64, ok := <-MyUInt64ROnlyChan"
}

UInt64ROnlyChan represents a receive-only channel

type UInt64SOnlyChan 

type UInt64SOnlyChan interface {
	ProvideUInt64(dat uint64) // the send function - aka "MyKind <- some UInt64"
}

UInt64SOnlyChan represents a send-only channel

type UInt8Chan 

type UInt8Chan interface {
	UInt8ROnlyChan // aka "<-chan" - receive only
	UInt8SOnlyChan // aka "chan<-" - send only
}

UInt8Chan represents a bidirectional channel

type UInt8ROnlyChan 

type UInt8ROnlyChan interface {
	RequestUInt8() (dat uint8)        // the receive function - aka "MyUInt8 := <-MyUInt8ROnlyChan"
	TryUInt8() (dat uint8, open bool) // the multi-valued comma-ok receive function - aka "MyUInt8, ok := <-MyUInt8ROnlyChan"
}

UInt8ROnlyChan represents a receive-only channel

type UInt8SOnlyChan 

type UInt8SOnlyChan interface {
	ProvideUInt8(dat uint8) // the send function - aka "MyKind <- some UInt8"
}

UInt8SOnlyChan 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.