list

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

View Source
const CAP = 10

CAP is the capacity of the buffered proxy channel

View Source
const ElementCAP = 10

ElementCAP is the capacity of the buffered proxy channel

View Source
const ElementQUE = 16

ElementQUE is the allocated size of the circular queue

View Source
const ElementSCAP = 10

ElementSCAP is the capacity of the buffered proxy channel

View Source
const ElementSQUE = 16

ElementSQUE is the allocated size of the circular queue

View Source
const ListSCAP = 10

ListSCAP is the capacity of the buffered proxy channel

View Source
const ListSQUE = 16

ListSQUE is the allocated size of the circular queue

View Source
const QUE = 16

QUE is the allocated size of the circular queue

Variables

This section is empty.

Functions

func Chan

func Chan(inp ...*list.List) chan *list.List

Chan returns a channel to receive all inputs before close.

func ChanElement

func ChanElement(inp ...*list.Element) chan *list.Element

ChanElement returns a channel to receive all inputs before close.

func ChanElementFuncErr

func ChanElementFuncErr(act func() (*list.Element, error)) <-chan *list.Element

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

func ChanElementFuncNil

func ChanElementFuncNil(act func() *list.Element) <-chan *list.Element

ChanElementFuncNil returns a channel to receive all results of act until nil before close.

func ChanElementFuncNok

func ChanElementFuncNok(act func() (*list.Element, bool)) <-chan *list.Element

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

func ChanElementS

func ChanElementS(inp ...[]*list.Element) chan []*list.Element

ChanElementS returns a channel to receive all inputs before close.

func ChanElementSFuncErr

func ChanElementSFuncErr(act func() ([]*list.Element, error)) <-chan []*list.Element

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

func ChanElementSFuncNil

func ChanElementSFuncNil(act func() []*list.Element) <-chan []*list.Element

ChanElementSFuncNil returns a channel to receive all results of act until nil before close.

func ChanElementSFuncNok

func ChanElementSFuncNok(act func() ([]*list.Element, bool)) <-chan []*list.Element

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

func ChanElementSSlice

func ChanElementSSlice(inp ...[][]*list.Element) chan []*list.Element

ChanElementSSlice returns a channel to receive all inputs before close.

func ChanElementSlice

func ChanElementSlice(inp ...[]*list.Element) chan *list.Element

ChanElementSlice returns a channel to receive all inputs before close.

func ChanFuncErr

func ChanFuncErr(act func() (*list.List, error)) <-chan *list.List

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

func ChanFuncNil

func ChanFuncNil(act func() *list.List) <-chan *list.List

ChanFuncNil returns a channel to receive all results of act until nil before close.

func ChanFuncNok

func ChanFuncNok(act func() (*list.List, bool)) <-chan *list.List

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

func ChanListS

func ChanListS(inp ...[]*list.List) chan []*list.List

ChanListS returns a channel to receive all inputs before close.

func ChanListSFuncErr

func ChanListSFuncErr(act func() ([]*list.List, error)) <-chan []*list.List

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

func ChanListSFuncNil

func ChanListSFuncNil(act func() []*list.List) <-chan []*list.List

ChanListSFuncNil returns a channel to receive all results of act until nil before close.

func ChanListSFuncNok

func ChanListSFuncNok(act func() ([]*list.List, bool)) <-chan []*list.List

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

func ChanListSSlice

func ChanListSSlice(inp ...[][]*list.List) chan []*list.List

ChanListSSlice returns a channel to receive all inputs before close.

func ChanSlice

func ChanSlice(inp ...[]*list.List) chan *list.List

ChanSlice returns a channel to receive all inputs before close.

func Daisy

func Daisy(inp <-chan *list.List, tube Tube) (out <-chan *list.List)

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

func DaisyChain

func DaisyChain(inp <-chan *list.List, tubes ...Tube) (out <-chan *list.List)

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

func Done

func Done(inp <-chan *list.List) chan struct{}

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

func DoneElement

func DoneElement(inp <-chan *list.Element) chan struct{}

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

func DoneElementFunc

func DoneElementFunc(inp <-chan *list.Element, act func(a *list.Element)) chan struct{}

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

func DoneElementS

func DoneElementS(inp <-chan []*list.Element) chan struct{}

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

func DoneElementSFunc

func DoneElementSFunc(inp <-chan []*list.Element, act func(a []*list.Element)) chan struct{}

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

func DoneElementSSlice

func DoneElementSSlice(inp <-chan []*list.Element) chan [][]*list.Element

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

func DoneElementSlice

func DoneElementSlice(inp <-chan *list.Element) chan []*list.Element

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

func DoneFunc

func DoneFunc(inp <-chan *list.List, act func(a *list.List)) chan struct{}

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

func DoneListS

func DoneListS(inp <-chan []*list.List) chan struct{}

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

func DoneListSFunc

func DoneListSFunc(inp <-chan []*list.List, act func(a []*list.List)) chan struct{}

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

func DoneListSSlice

func DoneListSSlice(inp <-chan []*list.List) chan [][]*list.List

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

func DoneSlice

func DoneSlice(inp <-chan *list.List) chan []*list.List

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 ElementDaisy

func ElementDaisy(inp <-chan *list.Element, tube ElementTube) (out <-chan *list.Element)

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

func ElementDaisyChain

func ElementDaisyChain(inp <-chan *list.Element, tubes ...ElementTube) (out <-chan *list.Element)

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

func ElementSDaisy

func ElementSDaisy(inp <-chan []*list.Element, tube ElementSTube) (out <-chan []*list.Element)

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

func ElementSDaisyChain

func ElementSDaisyChain(inp <-chan []*list.Element, tubes ...ElementSTube) (out <-chan []*list.Element)

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

func Join

func Join(out chan<- *list.List, inp ...*list.List) 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<- *list.List, inp <-chan *list.List) 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 JoinElement

func JoinElement(out chan<- *list.Element, inp ...*list.Element) chan struct{}

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

func JoinElementChan

func JoinElementChan(out chan<- *list.Element, inp <-chan *list.Element) chan struct{}

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

func JoinElementS

func JoinElementS(out chan<- []*list.Element, inp ...[]*list.Element) chan struct{}

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

func JoinElementSChan

func JoinElementSChan(out chan<- []*list.Element, inp <-chan []*list.Element) chan struct{}

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

func JoinElementSSlice

func JoinElementSSlice(out chan<- []*list.Element, inp ...[][]*list.Element) chan struct{}

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

func JoinElementSlice

func JoinElementSlice(out chan<- *list.Element, inp ...[]*list.Element) chan struct{}

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

func JoinListS

func JoinListS(out chan<- []*list.List, inp ...[]*list.List) chan struct{}

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

func JoinListSChan

func JoinListSChan(out chan<- []*list.List, inp <-chan []*list.List) chan struct{}

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

func JoinListSSlice

func JoinListSSlice(out chan<- []*list.List, inp ...[][]*list.List) chan struct{}

JoinListSSlice 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<- *list.List, inp ...[]*list.List) 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 ListSDaisy

func ListSDaisy(inp <-chan []*list.List, tube ListSTube) (out <-chan []*list.List)

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

func ListSDaisyChain

func ListSDaisyChain(inp <-chan []*list.List, tubes ...ListSTube) (out <-chan []*list.List)

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

func MakeChan

func MakeChan() chan *list.List

MakeChan returns a new open channel (simply a 'chan *list.List' 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 MakeElementChan

func MakeElementChan() chan *list.Element

MakeElementChan returns a new open channel (simply a 'chan *list.Element' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeElementBuffer) the channel is unbuffered.

func MakeElementSChan

func MakeElementSChan() chan []*list.Element

MakeElementSChan returns a new open channel (simply a 'chan []*list.Element' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeElementSBuffer) the channel is unbuffered.

func MakeListSChan

func MakeListSChan() chan []*list.List

MakeListSChan returns a new open channel (simply a 'chan []*list.List' that is).

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

This is useful to easily create corresponding variables such as

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

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 PipeListSBuffer) the channel is unbuffered.

func PipeBuffer

func PipeBuffer(inp <-chan *list.List, cap int) chan *list.List

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

func PipeElementBuffer

func PipeElementBuffer(inp <-chan *list.Element, cap int) chan *list.Element

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

func PipeElementFork

func PipeElementFork(inp <-chan *list.Element) (chan *list.Element, chan *list.Element)

PipeElementFork 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 PipeElementFunc

func PipeElementFunc(inp <-chan *list.Element, act func(a *list.Element) *list.Element) chan *list.Element

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

func PipeElementSBuffer

func PipeElementSBuffer(inp <-chan []*list.Element, cap int) chan []*list.Element

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

func PipeElementSFork

func PipeElementSFork(inp <-chan []*list.Element) (chan []*list.Element, chan []*list.Element)

PipeElementSFork 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 PipeElementSFunc

func PipeElementSFunc(inp <-chan []*list.Element, act func(a []*list.Element) []*list.Element) chan []*list.Element

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

func PipeFork

func PipeFork(inp <-chan *list.List) (chan *list.List, chan *list.List)

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 *list.List, act func(a *list.List) *list.List) chan *list.List

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 PipeListSBuffer

func PipeListSBuffer(inp <-chan []*list.List, cap int) chan []*list.List

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

func PipeListSFork

func PipeListSFork(inp <-chan []*list.List) (chan []*list.List, chan []*list.List)

PipeListSFork 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 PipeListSFunc

func PipeListSFunc(inp <-chan []*list.List, act func(a []*list.List) []*list.List) chan []*list.List

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

func SendProxy

func SendProxy(out chan<- *list.List) chan<- *list.List

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 SendProxyElement

func SendProxyElement(out chan<- *list.Element) chan<- *list.Element

SendProxyElement 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 SendProxyElementS

func SendProxyElementS(out chan<- []*list.Element) chan<- []*list.Element

SendProxyElementS 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 SendProxyListS

func SendProxyListS(out chan<- []*list.List) chan<- []*list.List

SendProxyListS 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"

Types

type ElementSTube

type ElementSTube func(inp <-chan []*list.Element, out <-chan []*list.Element)

ElementSTube is the signature for a pipe function.

type ElementTube

type ElementTube func(inp <-chan *list.Element, out <-chan *list.Element)

ElementTube is the signature for a pipe function.

type ListSTube

type ListSTube func(inp <-chan []*list.List, out <-chan []*list.List)

ListSTube is the signature for a pipe function.

type Tube

type Tube func(inp <-chan *list.List, out <-chan *list.List)

Tube 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