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

Documentation

Index

Constants

View Source
const CAP = 10

CAP is the capacity of the buffered proxy channel

View Source
const QUE = 16

QUE is the allocated size of the circular queue

View Source
const UInt16CAP = 10

UInt16CAP is the capacity of the buffered proxy channel

View Source
const UInt16QUE = 16

UInt16QUE is the allocated size of the circular queue

View Source
const UInt32CAP = 10

UInt32CAP is the capacity of the buffered proxy channel

View Source
const UInt32QUE = 16

UInt32QUE is the allocated size of the circular queue

View Source
const UInt64CAP = 10

UInt64CAP is the capacity of the buffered proxy channel

View Source
const UInt64QUE = 16

UInt64QUE is the allocated size of the circular queue

View Source
const UInt8CAP = 10

UInt8CAP is the capacity of the buffered proxy channel

View Source
const UInt8QUE = 16

UInt8QUE is the allocated size of the circular queue

Variables

This section is empty.

Functions

func Chan

func Chan(inp ...uint) chan uint

Chan returns a channel to receive all inputs before close.

func ChanFuncErr

func ChanFuncErr(act func() (uint, error)) <-chan uint

ChanFuncErr returns a channel to receive all results of act until err != nil before close.

func ChanFuncNok

func ChanFuncNok(act func() (uint, bool)) <-chan uint

ChanFuncNok returns a channel to receive all results of act until nok before close.

func ChanSlice

func ChanSlice(inp ...[]uint) chan uint

ChanSlice returns a channel to receive all inputs before close.

func ChanUInt16

func ChanUInt16(inp ...uint16) chan uint16

ChanUInt16 returns a channel to receive all inputs before close.

func ChanUInt16FuncErr

func ChanUInt16FuncErr(act func() (uint16, error)) <-chan uint16

ChanUInt16FuncErr returns a channel to receive all results of act until err != nil before close.

func ChanUInt16FuncNok

func ChanUInt16FuncNok(act func() (uint16, bool)) <-chan uint16

ChanUInt16FuncNok returns a channel to receive all results of act until nok before close.

func ChanUInt16Slice

func ChanUInt16Slice(inp ...[]uint16) chan uint16

ChanUInt16Slice returns a channel to receive all inputs before close.

func ChanUInt32

func ChanUInt32(inp ...uint32) chan uint32

ChanUInt32 returns a channel to receive all inputs before close.

func ChanUInt32FuncErr

func ChanUInt32FuncErr(act func() (uint32, error)) <-chan uint32

ChanUInt32FuncErr returns a channel to receive all results of act until err != nil before close.

func ChanUInt32FuncNok

func ChanUInt32FuncNok(act func() (uint32, bool)) <-chan uint32

ChanUInt32FuncNok returns a channel to receive all results of act until nok before close.

func ChanUInt32Slice

func ChanUInt32Slice(inp ...[]uint32) chan uint32

ChanUInt32Slice returns a channel to receive all inputs before close.

func ChanUInt64

func ChanUInt64(inp ...uint64) chan uint64

ChanUInt64 returns a channel to receive all inputs before close.

func ChanUInt64FuncErr

func ChanUInt64FuncErr(act func() (uint64, error)) <-chan uint64

ChanUInt64FuncErr returns a channel to receive all results of act until err != nil before close.

func ChanUInt64FuncNok

func ChanUInt64FuncNok(act func() (uint64, bool)) <-chan uint64

ChanUInt64FuncNok returns a channel to receive all results of act until nok before close.

func ChanUInt64Slice

func ChanUInt64Slice(inp ...[]uint64) chan uint64

ChanUInt64Slice returns a channel to receive all inputs before close.

func ChanUInt8

func ChanUInt8(inp ...uint8) chan uint8

ChanUInt8 returns a channel to receive all inputs before close.

func ChanUInt8FuncErr

func ChanUInt8FuncErr(act func() (uint8, error)) <-chan uint8

ChanUInt8FuncErr returns a channel to receive all results of act until err != nil before close.

func ChanUInt8FuncNok

func ChanUInt8FuncNok(act func() (uint8, bool)) <-chan uint8

ChanUInt8FuncNok returns a channel to receive all results of act until nok before close.

func ChanUInt8Slice

func ChanUInt8Slice(inp ...[]uint8) chan uint8

ChanUInt8Slice returns a channel to receive all inputs before close.

func Daisy

func Daisy(inp <-chan uint, tube Tube) (out <-chan uint)

Daisy returns a channel to receive all inp after having passed thru tube.

func DaisyChain

func DaisyChain(inp <-chan uint, tubes ...Tube) (out <-chan uint)

DaisyChain returns a channel to receive all inp after having passed thru all tubes.

func Done

func Done(inp <-chan uint) chan struct{}

Done returns a channel to receive one signal before close after inp has been drained.

func DoneFunc

func DoneFunc(inp <-chan uint, act func(a uint)) chan struct{}

DoneFunc returns a channel to receive one signal before close after act has been applied to all inp.

func DoneSlice

func DoneSlice(inp <-chan uint) chan []uint

DoneSlice returns a channel which will receive a slice of all the s received on inp channel before close. Unlike Done, a full slice is sent once, not just an event.

func DoneUInt16

func DoneUInt16(inp <-chan uint16) chan struct{}

DoneUInt16 returns a channel to receive one signal before close after inp has been drained.

func DoneUInt16Func

func DoneUInt16Func(inp <-chan uint16, act func(a uint16)) chan struct{}

DoneUInt16Func returns a channel to receive one signal before close after act has been applied to all inp.

func DoneUInt16Slice

func DoneUInt16Slice(inp <-chan uint16) chan []uint16

DoneUInt16Slice returns a channel which will receive a slice of all the UInt16s received on inp channel before close. Unlike DoneUInt16, a full slice is sent once, not just an event.

func DoneUInt32

func DoneUInt32(inp <-chan uint32) chan struct{}

DoneUInt32 returns a channel to receive one signal before close after inp has been drained.

func DoneUInt32Func

func DoneUInt32Func(inp <-chan uint32, act func(a uint32)) chan struct{}

DoneUInt32Func returns a channel to receive one signal before close after act has been applied to all inp.

func DoneUInt32Slice

func DoneUInt32Slice(inp <-chan uint32) chan []uint32

DoneUInt32Slice returns a channel which will receive a slice of all the UInt32s received on inp channel before close. Unlike DoneUInt32, a full slice is sent once, not just an event.

func DoneUInt64

func DoneUInt64(inp <-chan uint64) chan struct{}

DoneUInt64 returns a channel to receive one signal before close after inp has been drained.

func DoneUInt64Func

func DoneUInt64Func(inp <-chan uint64, act func(a uint64)) chan struct{}

DoneUInt64Func returns a channel to receive one signal before close after act has been applied to all inp.

func DoneUInt64Slice

func DoneUInt64Slice(inp <-chan uint64) chan []uint64

DoneUInt64Slice returns a channel which will receive a slice of all the UInt64s received on inp channel before close. Unlike DoneUInt64, a full slice is sent once, not just an event.

func DoneUInt8

func DoneUInt8(inp <-chan uint8) chan struct{}

DoneUInt8 returns a channel to receive one signal before close after inp has been drained.

func DoneUInt8Func

func DoneUInt8Func(inp <-chan uint8, act func(a uint8)) chan struct{}

DoneUInt8Func returns a channel to receive one signal before close after act has been applied to all inp.

func DoneUInt8Slice

func DoneUInt8Slice(inp <-chan uint8) chan []uint8

DoneUInt8Slice returns a channel which will receive a slice of all the UInt8s received on inp channel before close. Unlike DoneUInt8, a full slice is sent once, not just an event.

func Join

func Join(out chan<- uint, inp ...uint) chan struct{}

Join sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinChan

func JoinChan(out chan<- uint, inp <-chan uint) chan struct{}

JoinChan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinSlice

func JoinSlice(out chan<- uint, inp ...[]uint) chan struct{}

JoinSlice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt16

func JoinUInt16(out chan<- uint16, inp ...uint16) chan struct{}

JoinUInt16 sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt16Chan

func JoinUInt16Chan(out chan<- uint16, inp <-chan uint16) chan struct{}

JoinUInt16Chan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt16Slice

func JoinUInt16Slice(out chan<- uint16, inp ...[]uint16) chan struct{}

JoinUInt16Slice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt32

func JoinUInt32(out chan<- uint32, inp ...uint32) chan struct{}

JoinUInt32 sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt32Chan

func JoinUInt32Chan(out chan<- uint32, inp <-chan uint32) chan struct{}

JoinUInt32Chan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt32Slice

func JoinUInt32Slice(out chan<- uint32, inp ...[]uint32) chan struct{}

JoinUInt32Slice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt64

func JoinUInt64(out chan<- uint64, inp ...uint64) chan struct{}

JoinUInt64 sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt64Chan

func JoinUInt64Chan(out chan<- uint64, inp <-chan uint64) chan struct{}

JoinUInt64Chan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt64Slice

func JoinUInt64Slice(out chan<- uint64, inp ...[]uint64) chan struct{}

JoinUInt64Slice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt8

func JoinUInt8(out chan<- uint8, inp ...uint8) chan struct{}

JoinUInt8 sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt8Chan

func JoinUInt8Chan(out chan<- uint8, inp <-chan uint8) chan struct{}

JoinUInt8Chan sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func JoinUInt8Slice

func JoinUInt8Slice(out chan<- uint8, inp ...[]uint8) chan struct{}

JoinUInt8Slice sends inputs on the given out channel and returns a done channel to receive one signal when inp has been drained

func MakeChan

func MakeChan() chan uint

MakeChan returns a new open channel (simply a 'chan uint' that is).

Note: No '-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myPipelineStartsHere := MakeChan()
// ... lot's of code to design and build Your favourite "myWorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myPipelineStartsHere <- drop
}
close(myPipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeBuffer) the channel is unbuffered.

func MakeUInt16Chan

func MakeUInt16Chan() chan uint16

MakeUInt16Chan returns a new open channel (simply a 'chan uint16' that is).

Note: No 'UInt16-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myUInt16PipelineStartsHere := MakeUInt16Chan()
// ... lot's of code to design and build Your favourite "myUInt16WorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myUInt16PipelineStartsHere <- drop
}
close(myUInt16PipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeUInt16Buffer) the channel is unbuffered.

func MakeUInt32Chan

func MakeUInt32Chan() chan uint32

MakeUInt32Chan returns a new open channel (simply a 'chan uint32' that is).

Note: No 'UInt32-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myUInt32PipelineStartsHere := MakeUInt32Chan()
// ... lot's of code to design and build Your favourite "myUInt32WorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myUInt32PipelineStartsHere <- drop
}
close(myUInt32PipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeUInt32Buffer) the channel is unbuffered.

func MakeUInt64Chan

func MakeUInt64Chan() chan uint64

MakeUInt64Chan returns a new open channel (simply a 'chan uint64' that is).

Note: No 'UInt64-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myUInt64PipelineStartsHere := MakeUInt64Chan()
// ... lot's of code to design and build Your favourite "myUInt64WorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myUInt64PipelineStartsHere <- drop
}
close(myUInt64PipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeUInt64Buffer) the channel is unbuffered.

func MakeUInt8Chan

func MakeUInt8Chan() chan uint8

MakeUInt8Chan returns a new open channel (simply a 'chan uint8' that is).

Note: No 'UInt8-producer' is launched here yet! (as is in all the other functions).

This is useful to easily create corresponding variables such as

var myUInt8PipelineStartsHere := MakeUInt8Chan()
// ... lot's of code to design and build Your favourite "myUInt8WorkflowPipeline"
// ...
// ... *before* You start pouring data into it, e.g. simply via:
for drop := range water {
	myUInt8PipelineStartsHere <- drop
}
close(myUInt8PipelineStartsHere)

Hint: especially helpful, if Your piping library operates on some hidden (non-exported) type (or on a type imported from elsewhere - and You don't want/need or should(!) have to care.)

Note: as always (except for PipeUInt8Buffer) the channel is unbuffered.

func Merge

func Merge(inps ...<-chan uint) (out <-chan uint)

Merge returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed channel is returned.

func MergeUInt16

func MergeUInt16(inps ...<-chan uint16) (out <-chan uint16)

MergeUInt16 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt16channel is returned.

func MergeUInt32

func MergeUInt32(inps ...<-chan uint32) (out <-chan uint32)

MergeUInt32 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt32channel is returned.

func MergeUInt64

func MergeUInt64(inps ...<-chan uint64) (out <-chan uint64)

MergeUInt64 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt64channel is returned.

func MergeUInt8

func MergeUInt8(inps ...<-chan uint8) (out <-chan uint8)

MergeUInt8 returns a channel to receive all inputs sorted and free of duplicates. Each input channel needs to be ascending; sorted and free of duplicates.

Note: If no inputs are given, a closed UInt8channel is returned.

func PipeBuffer

func PipeBuffer(inp <-chan uint, cap int) chan uint

PipeBuffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeFork

func PipeFork(inp <-chan uint) (chan uint, chan uint)

PipeFork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeFunc

func PipeFunc(inp <-chan uint, act func(a uint) uint) chan uint

PipeFunc returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeMap for functional people, but 'map' has a very different meaning in go lang.

func PipeUInt16Buffer

func PipeUInt16Buffer(inp <-chan uint16, cap int) chan uint16

PipeUInt16Buffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeUInt16Fork

func PipeUInt16Fork(inp <-chan uint16) (chan uint16, chan uint16)

PipeUInt16Fork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeUInt16Func

func PipeUInt16Func(inp <-chan uint16, act func(a uint16) uint16) chan uint16

PipeUInt16Func returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeUInt16Map for functional people, but 'map' has a very different meaning in go lang.

func PipeUInt32Buffer

func PipeUInt32Buffer(inp <-chan uint32, cap int) chan uint32

PipeUInt32Buffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeUInt32Fork

func PipeUInt32Fork(inp <-chan uint32) (chan uint32, chan uint32)

PipeUInt32Fork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeUInt32Func

func PipeUInt32Func(inp <-chan uint32, act func(a uint32) uint32) chan uint32

PipeUInt32Func returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeUInt32Map for functional people, but 'map' has a very different meaning in go lang.

func PipeUInt64Buffer

func PipeUInt64Buffer(inp <-chan uint64, cap int) chan uint64

PipeUInt64Buffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeUInt64Fork

func PipeUInt64Fork(inp <-chan uint64) (chan uint64, chan uint64)

PipeUInt64Fork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeUInt64Func

func PipeUInt64Func(inp <-chan uint64, act func(a uint64) uint64) chan uint64

PipeUInt64Func returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeUInt64Map for functional people, but 'map' has a very different meaning in go lang.

func PipeUInt8Buffer

func PipeUInt8Buffer(inp <-chan uint8, cap int) chan uint8

PipeUInt8Buffer returns a buffered channel with capacity cap to receive all inp before close.

func PipeUInt8Fork

func PipeUInt8Fork(inp <-chan uint8) (chan uint8, chan uint8)

PipeUInt8Fork returns two channels to receive every result of inp before close.

Note: Yes, it is a VERY simple fanout - but sometimes all You need.

func PipeUInt8Func

func PipeUInt8Func(inp <-chan uint8, act func(a uint8) uint8) chan uint8

PipeUInt8Func returns a channel to receive every result of act applied to inp before close. Note: it 'could' be PipeUInt8Map for functional people, but 'map' has a very different meaning in go lang.

func SendProxy

func SendProxy(out chan<- uint) chan<- uint

SendProxy returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyUInt16

func SendProxyUInt16(out chan<- uint16) chan<- uint16

SendProxyUInt16 returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyUInt32

func SendProxyUInt32(out chan<- uint32) chan<- uint32

SendProxyUInt32 returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyUInt64

func SendProxyUInt64(out chan<- uint64) chan<- uint64

SendProxyUInt64 returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func SendProxyUInt8

func SendProxyUInt8(out chan<- uint8) chan<- uint8

SendProxyUInt8 returns a channel to serve as a sending proxy to 'out'. Uses a goroutine to receive values from 'out' and store them in an expanding buffer, so that sending to 'out' never blocks.

Note: the expanding buffer is implemented via "container/ring"

func UInt16Daisy

func UInt16Daisy(inp <-chan uint16, tube UInt16Tube) (out <-chan uint16)

UInt16Daisy returns a channel to receive all inp after having passed thru tube.

func UInt16DaisyChain

func UInt16DaisyChain(inp <-chan uint16, tubes ...UInt16Tube) (out <-chan uint16)

UInt16DaisyChain returns a channel to receive all inp after having passed thru all tubes.

func UInt32Daisy

func UInt32Daisy(inp <-chan uint32, tube UInt32Tube) (out <-chan uint32)

UInt32Daisy returns a channel to receive all inp after having passed thru tube.

func UInt32DaisyChain

func UInt32DaisyChain(inp <-chan uint32, tubes ...UInt32Tube) (out <-chan uint32)

UInt32DaisyChain returns a channel to receive all inp after having passed thru all tubes.

func UInt64Daisy

func UInt64Daisy(inp <-chan uint64, tube UInt64Tube) (out <-chan uint64)

UInt64Daisy returns a channel to receive all inp after having passed thru tube.

func UInt64DaisyChain

func UInt64DaisyChain(inp <-chan uint64, tubes ...UInt64Tube) (out <-chan uint64)

UInt64DaisyChain returns a channel to receive all inp after having passed thru all tubes.

func UInt8Daisy

func UInt8Daisy(inp <-chan uint8, tube UInt8Tube) (out <-chan uint8)

UInt8Daisy returns a channel to receive all inp after having passed thru tube.

func UInt8DaisyChain

func UInt8DaisyChain(inp <-chan uint8, tubes ...UInt8Tube) (out <-chan uint8)

UInt8DaisyChain returns a channel to receive all inp after having passed thru all tubes.

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 Tube

type Tube func(inp <-chan uint, out <-chan uint)

Tube is the signature for a pipe function.

type UInt16Tube

type UInt16Tube func(inp <-chan uint16, out <-chan uint16)

UInt16Tube is the signature for a pipe function.

type UInt32Tube

type UInt32Tube func(inp <-chan uint32, out <-chan uint32)

UInt32Tube is the signature for a pipe function.

type UInt64Tube

type UInt64Tube func(inp <-chan uint64, out <-chan uint64)

UInt64Tube is the signature for a pipe function.

type UInt8Tube

type UInt8Tube func(inp <-chan uint8, out <-chan uint8)

UInt8Tube is the signature for a pipe function.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL