fsc

func ChanFsBase ¶

func ChanFsBase(inp ...*fs.FsBase) (out <-chan *fs.FsBase)

ChanFsBase returns a channel to receive all inputs before close.

func ChanFsBaseFuncErr ¶

func ChanFsBaseFuncErr(act func() (*fs.FsBase, error)) (out <-chan *fs.FsBase)

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

func ChanFsBaseFuncNil ¶

func ChanFsBaseFuncNil(act func() *fs.FsBase) (out <-chan *fs.FsBase)

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

func ChanFsBaseFuncNok ¶

func ChanFsBaseFuncNok(act func() (*fs.FsBase, bool)) (out <-chan *fs.FsBase)

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

func ChanFsBaseS ¶

func ChanFsBaseS(inp ...fs.FsBaseS) (out <-chan fs.FsBaseS)

ChanFsBaseS returns a channel to receive all inputs before close.

func ChanFsBaseSFuncErr ¶

func ChanFsBaseSFuncErr(act func() (fs.FsBaseS, error)) (out <-chan fs.FsBaseS)

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

func ChanFsBaseSFuncNil ¶

func ChanFsBaseSFuncNil(act func() fs.FsBaseS) (out <-chan fs.FsBaseS)

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

func ChanFsBaseSFuncNok ¶

func ChanFsBaseSFuncNok(act func() (fs.FsBaseS, bool)) (out <-chan fs.FsBaseS)

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

func ChanFsBaseSSlice ¶

func ChanFsBaseSSlice(inp ...[]fs.FsBaseS) (out <-chan fs.FsBaseS)

ChanFsBaseSSlice returns a channel to receive all inputs before close.

func ChanFsBaseSlice ¶

func ChanFsBaseSlice(inp ...[]*fs.FsBase) (out <-chan *fs.FsBase)

ChanFsBaseSlice returns a channel to receive all inputs before close.

func ChanFsData ¶

func ChanFsData(inp ...*fs.FsData) (out <-chan *fs.FsData)

ChanFsData returns a channel to receive all inputs before close.

func ChanFsDataFuncErr ¶

func ChanFsDataFuncErr(act func() (*fs.FsData, error)) (out <-chan *fs.FsData)

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

func ChanFsDataFuncNil ¶

func ChanFsDataFuncNil(act func() *fs.FsData) (out <-chan *fs.FsData)

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

func ChanFsDataFuncNok ¶

func ChanFsDataFuncNok(act func() (*fs.FsData, bool)) (out <-chan *fs.FsData)

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

func ChanFsDataS ¶

func ChanFsDataS(inp ...fs.FsDataS) (out <-chan fs.FsDataS)

ChanFsDataS returns a channel to receive all inputs before close.

func ChanFsDataSFuncErr ¶

func ChanFsDataSFuncErr(act func() (fs.FsDataS, error)) (out <-chan fs.FsDataS)

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

func ChanFsDataSFuncNil ¶

func ChanFsDataSFuncNil(act func() fs.FsDataS) (out <-chan fs.FsDataS)

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

func ChanFsDataSFuncNok ¶

func ChanFsDataSFuncNok(act func() (fs.FsDataS, bool)) (out <-chan fs.FsDataS)

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

func ChanFsDataSSlice ¶

func ChanFsDataSSlice(inp ...[]fs.FsDataS) (out <-chan fs.FsDataS)

ChanFsDataSSlice returns a channel to receive all inputs before close.

func ChanFsDataSlice ¶

func ChanFsDataSlice(inp ...[]*fs.FsData) (out <-chan *fs.FsData)

ChanFsDataSlice returns a channel to receive all inputs before close.

func ChanFsFile ¶

func ChanFsFile(inp ...*fs.FsFile) (out <-chan *fs.FsFile)

ChanFsFile returns a channel to receive all inputs before close.

func ChanFsFileFuncErr ¶

func ChanFsFileFuncErr(act func() (*fs.FsFile, error)) (out <-chan *fs.FsFile)

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

func ChanFsFileFuncNil ¶

func ChanFsFileFuncNil(act func() *fs.FsFile) (out <-chan *fs.FsFile)

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

func ChanFsFileFuncNok ¶

func ChanFsFileFuncNok(act func() (*fs.FsFile, bool)) (out <-chan *fs.FsFile)

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

func ChanFsFileS ¶

func ChanFsFileS(inp ...fs.FsFileS) (out <-chan fs.FsFileS)

ChanFsFileS returns a channel to receive all inputs before close.

func ChanFsFileSFuncErr ¶

func ChanFsFileSFuncErr(act func() (fs.FsFileS, error)) (out <-chan fs.FsFileS)

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

func ChanFsFileSFuncNil ¶

func ChanFsFileSFuncNil(act func() fs.FsFileS) (out <-chan fs.FsFileS)

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

func ChanFsFileSFuncNok ¶

func ChanFsFileSFuncNok(act func() (fs.FsFileS, bool)) (out <-chan fs.FsFileS)

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

func ChanFsFileSSlice ¶

func ChanFsFileSSlice(inp ...[]fs.FsFileS) (out <-chan fs.FsFileS)

ChanFsFileSSlice returns a channel to receive all inputs before close.

func ChanFsFileSlice ¶

func ChanFsFileSlice(inp ...[]*fs.FsFile) (out <-chan *fs.FsFile)

ChanFsFileSlice returns a channel to receive all inputs before close.

func ChanFsFold ¶

func ChanFsFold(inp ...*fs.FsFold) (out <-chan *fs.FsFold)

ChanFsFold returns a channel to receive all inputs before close.

func ChanFsFoldFuncErr ¶

func ChanFsFoldFuncErr(act func() (*fs.FsFold, error)) (out <-chan *fs.FsFold)

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

func ChanFsFoldFuncNil ¶

func ChanFsFoldFuncNil(act func() *fs.FsFold) (out <-chan *fs.FsFold)

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

func ChanFsFoldFuncNok ¶

func ChanFsFoldFuncNok(act func() (*fs.FsFold, bool)) (out <-chan *fs.FsFold)

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

func ChanFsFoldS ¶

func ChanFsFoldS(inp ...fs.FsFoldS) (out <-chan fs.FsFoldS)

ChanFsFoldS returns a channel to receive all inputs before close.

func ChanFsFoldSFuncErr ¶

func ChanFsFoldSFuncErr(act func() (fs.FsFoldS, error)) (out <-chan fs.FsFoldS)

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

func ChanFsFoldSFuncNil ¶

func ChanFsFoldSFuncNil(act func() fs.FsFoldS) (out <-chan fs.FsFoldS)

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

func ChanFsFoldSFuncNok ¶

func ChanFsFoldSFuncNok(act func() (fs.FsFoldS, bool)) (out <-chan fs.FsFoldS)

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

func ChanFsFoldSSlice ¶

func ChanFsFoldSSlice(inp ...[]fs.FsFoldS) (out <-chan fs.FsFoldS)

ChanFsFoldSSlice returns a channel to receive all inputs before close.

func ChanFsFoldSlice ¶

func ChanFsFoldSlice(inp ...[]*fs.FsFold) (out <-chan *fs.FsFold)

ChanFsFoldSlice returns a channel to receive all inputs before close.

func ChanFsInfoS ¶

func ChanFsInfoS(inp ...fs.FsInfoS) (out <-chan fs.FsInfoS)

ChanFsInfoS returns a channel to receive all inputs before close.

func ChanFsInfoSFuncErr ¶

func ChanFsInfoSFuncErr(act func() (fs.FsInfoS, error)) (out <-chan fs.FsInfoS)

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

func ChanFsInfoSFuncNil ¶

func ChanFsInfoSFuncNil(act func() fs.FsInfoS) (out <-chan fs.FsInfoS)

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

func ChanFsInfoSFuncNok ¶

func ChanFsInfoSFuncNok(act func() (fs.FsInfoS, bool)) (out <-chan fs.FsInfoS)

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

func ChanFsInfoSSlice ¶

func ChanFsInfoSSlice(inp ...[]fs.FsInfoS) (out <-chan fs.FsInfoS)

ChanFsInfoSSlice returns a channel to receive all inputs before close.

func ChanFsPathS ¶

func ChanFsPathS(inp ...fs.FsPathS) (out <-chan fs.FsPathS)

ChanFsPathS returns a channel to receive all inputs before close.

func ChanFsPathSFuncErr ¶

func ChanFsPathSFuncErr(act func() (fs.FsPathS, error)) (out <-chan fs.FsPathS)

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

func ChanFsPathSFuncNil ¶

func ChanFsPathSFuncNil(act func() fs.FsPathS) (out <-chan fs.FsPathS)

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

func ChanFsPathSFuncNok ¶

func ChanFsPathSFuncNok(act func() (fs.FsPathS, bool)) (out <-chan fs.FsPathS)

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

func ChanFsPathSSlice ¶

func ChanFsPathSSlice(inp ...[]fs.FsPathS) (out <-chan fs.FsPathS)

ChanFsPathSSlice returns a channel to receive all inputs before close.

func ChanPattern ¶

func ChanPattern(inp ...*fs.Pattern) (out <-chan *fs.Pattern)

ChanPattern returns a channel to receive all inputs before close.

func ChanPatternFuncErr ¶

func ChanPatternFuncErr(act func() (*fs.Pattern, error)) (out <-chan *fs.Pattern)

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

func ChanPatternFuncNil ¶

func ChanPatternFuncNil(act func() *fs.Pattern) (out <-chan *fs.Pattern)

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

func ChanPatternFuncNok ¶

func ChanPatternFuncNok(act func() (*fs.Pattern, bool)) (out <-chan *fs.Pattern)

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

func ChanPatternS ¶

func ChanPatternS(inp ...fs.PatternS) (out <-chan fs.PatternS)

ChanPatternS returns a channel to receive all inputs before close.

func ChanPatternSFuncErr ¶

func ChanPatternSFuncErr(act func() (fs.PatternS, error)) (out <-chan fs.PatternS)

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

func ChanPatternSFuncNil ¶

func ChanPatternSFuncNil(act func() fs.PatternS) (out <-chan fs.PatternS)

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

func ChanPatternSFuncNok ¶

func ChanPatternSFuncNok(act func() (fs.PatternS, bool)) (out <-chan fs.PatternS)

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

func ChanPatternSSlice ¶

func ChanPatternSSlice(inp ...[]fs.PatternS) (out <-chan fs.PatternS)

ChanPatternSSlice returns a channel to receive all inputs before close.

func ChanPatternSlice ¶

func ChanPatternSlice(inp ...[]*fs.Pattern) (out <-chan *fs.Pattern)

ChanPatternSlice returns a channel to receive all inputs before close.

func DoneFsBase ¶

func DoneFsBase(inp <-chan *fs.FsBase) (done <-chan struct{})

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

func DoneFsBaseFunc ¶

func DoneFsBaseFunc(inp <-chan *fs.FsBase, act func(a *fs.FsBase)) (out <-chan struct{})

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

func DoneFsBaseS ¶

func DoneFsBaseS(inp <-chan fs.FsBaseS) (done <-chan struct{})

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

func DoneFsBaseSFunc ¶

func DoneFsBaseSFunc(inp <-chan fs.FsBaseS, act func(a fs.FsBaseS)) (out <-chan struct{})

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

func DoneFsBaseSSlice ¶

func DoneFsBaseSSlice(inp <-chan fs.FsBaseS) (done <-chan ([]fs.FsBaseS))

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

func DoneFsBaseSlice ¶

func DoneFsBaseSlice(inp <-chan *fs.FsBase) (done <-chan ([]*fs.FsBase))

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

func DoneFsData ¶

func DoneFsData(inp <-chan *fs.FsData) (done <-chan struct{})

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

func DoneFsDataFunc ¶

func DoneFsDataFunc(inp <-chan *fs.FsData, act func(a *fs.FsData)) (out <-chan struct{})

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

func DoneFsDataS ¶

func DoneFsDataS(inp <-chan fs.FsDataS) (done <-chan struct{})

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

func DoneFsDataSFunc ¶

func DoneFsDataSFunc(inp <-chan fs.FsDataS, act func(a fs.FsDataS)) (out <-chan struct{})

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

func DoneFsDataSSlice ¶

func DoneFsDataSSlice(inp <-chan fs.FsDataS) (done <-chan ([]fs.FsDataS))

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

func DoneFsDataSlice ¶

func DoneFsDataSlice(inp <-chan *fs.FsData) (done <-chan ([]*fs.FsData))

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

func DoneFsFile ¶

func DoneFsFile(inp <-chan *fs.FsFile) (done <-chan struct{})

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

func DoneFsFileFunc ¶

func DoneFsFileFunc(inp <-chan *fs.FsFile, act func(a *fs.FsFile)) (out <-chan struct{})

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

func DoneFsFileS ¶

func DoneFsFileS(inp <-chan fs.FsFileS) (done <-chan struct{})

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

func DoneFsFileSFunc ¶

func DoneFsFileSFunc(inp <-chan fs.FsFileS, act func(a fs.FsFileS)) (out <-chan struct{})

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

func DoneFsFileSSlice ¶

func DoneFsFileSSlice(inp <-chan fs.FsFileS) (done <-chan ([]fs.FsFileS))

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

func DoneFsFileSlice ¶

func DoneFsFileSlice(inp <-chan *fs.FsFile) (done <-chan ([]*fs.FsFile))

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

func DoneFsFold ¶

func DoneFsFold(inp <-chan *fs.FsFold) (done <-chan struct{})

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

func DoneFsFoldFunc ¶

func DoneFsFoldFunc(inp <-chan *fs.FsFold, act func(a *fs.FsFold)) (out <-chan struct{})

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

func DoneFsFoldS ¶

func DoneFsFoldS(inp <-chan fs.FsFoldS) (done <-chan struct{})

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

func DoneFsFoldSFunc ¶

func DoneFsFoldSFunc(inp <-chan fs.FsFoldS, act func(a fs.FsFoldS)) (out <-chan struct{})

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

func DoneFsFoldSSlice ¶

func DoneFsFoldSSlice(inp <-chan fs.FsFoldS) (done <-chan ([]fs.FsFoldS))

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

func DoneFsFoldSlice ¶

func DoneFsFoldSlice(inp <-chan *fs.FsFold) (done <-chan ([]*fs.FsFold))

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

func DoneFsInfoS ¶

func DoneFsInfoS(inp <-chan fs.FsInfoS) (done <-chan struct{})

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

func DoneFsInfoSFunc ¶

func DoneFsInfoSFunc(inp <-chan fs.FsInfoS, act func(a fs.FsInfoS)) (out <-chan struct{})

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

func DoneFsInfoSSlice ¶

func DoneFsInfoSSlice(inp <-chan fs.FsInfoS) (done <-chan ([]fs.FsInfoS))

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

func DoneFsPathS ¶

func DoneFsPathS(inp <-chan fs.FsPathS) (done <-chan struct{})

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

func DoneFsPathSFunc ¶

func DoneFsPathSFunc(inp <-chan fs.FsPathS, act func(a fs.FsPathS)) (out <-chan struct{})

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

func DoneFsPathSSlice ¶

func DoneFsPathSSlice(inp <-chan fs.FsPathS) (done <-chan ([]fs.FsPathS))

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

func DonePattern ¶

func DonePattern(inp <-chan *fs.Pattern) (done <-chan struct{})

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

func DonePatternFunc ¶

func DonePatternFunc(inp <-chan *fs.Pattern, act func(a *fs.Pattern)) (out <-chan struct{})

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

func DonePatternS ¶

func DonePatternS(inp <-chan fs.PatternS) (done <-chan struct{})

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

func DonePatternSFunc ¶

func DonePatternSFunc(inp <-chan fs.PatternS, act func(a fs.PatternS)) (out <-chan struct{})

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

func DonePatternSSlice ¶

func DonePatternSSlice(inp <-chan fs.PatternS) (done <-chan ([]fs.PatternS))

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

func DonePatternSlice ¶

func DonePatternSlice(inp <-chan *fs.Pattern) (done <-chan ([]*fs.Pattern))

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

func FsBaseDaisy ¶

func FsBaseDaisy(inp <-chan *fs.FsBase, tube FsBaseTube) (out <-chan *fs.FsBase)

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

func FsBaseDaisyChain ¶

func FsBaseDaisyChain(inp <-chan *fs.FsBase, tubes ...FsBaseTube) (out <-chan *fs.FsBase)

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

func FsBasePrintFunc ¶

func FsBasePrintFunc(prefix string) func(fp *fs.FsBase) *fs.FsBase

FsBasePrintFunc is a simple helper for PipeFsBaseFunc

func FsBaseSDaisy ¶

func FsBaseSDaisy(inp <-chan fs.FsBaseS, tube FsBaseSTube) (out <-chan fs.FsBaseS)

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

func FsBaseSDaisyChain ¶

func FsBaseSDaisyChain(inp <-chan fs.FsBaseS, tubes ...FsBaseSTube) (out <-chan fs.FsBaseS)

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

func FsBaseSPrintFunc ¶

func FsBaseSPrintFunc(prefix string) func(fp fs.FsBaseS) fs.FsBaseS

FsBaseSPrintFunc is a simple helper for PipeFsBaseSFunc

func FsDataDaisy ¶

func FsDataDaisy(inp <-chan *fs.FsData, tube FsDataTube) (out <-chan *fs.FsData)

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

func FsDataDaisyChain ¶

func FsDataDaisyChain(inp <-chan *fs.FsData, tubes ...FsDataTube) (out <-chan *fs.FsData)

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

func FsDataPrintFunc ¶

func FsDataPrintFunc(prefix string) func(fp *fs.FsData) *fs.FsData

FsDataPrintFunc is a simple helper for PipeFsDataFunc

func FsDataSDaisy ¶

func FsDataSDaisy(inp <-chan fs.FsDataS, tube FsDataSTube) (out <-chan fs.FsDataS)

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

func FsDataSDaisyChain ¶

func FsDataSDaisyChain(inp <-chan fs.FsDataS, tubes ...FsDataSTube) (out <-chan fs.FsDataS)

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

func FsDataSPrintFunc ¶

func FsDataSPrintFunc(prefix string) func(fp fs.FsDataS) fs.FsDataS

FsDataSPrintFunc is a simple helper for PipeFsDataSFunc

func FsFileDaisy ¶

func FsFileDaisy(inp <-chan *fs.FsFile, tube FsFileTube) (out <-chan *fs.FsFile)

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

func FsFileDaisyChain ¶

func FsFileDaisyChain(inp <-chan *fs.FsFile, tubes ...FsFileTube) (out <-chan *fs.FsFile)

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

func FsFilePrintFunc ¶

func FsFilePrintFunc(prefix string) func(fp *fs.FsFile) *fs.FsFile

FsFilePrintFunc is a simple helper for PipeFsFileFunc

func FsFileSDaisy ¶

func FsFileSDaisy(inp <-chan fs.FsFileS, tube FsFileSTube) (out <-chan fs.FsFileS)

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

func FsFileSDaisyChain ¶

func FsFileSDaisyChain(inp <-chan fs.FsFileS, tubes ...FsFileSTube) (out <-chan fs.FsFileS)

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

func FsFileSPrintFunc ¶

func FsFileSPrintFunc(prefix string) func(fp fs.FsFileS) fs.FsFileS

FsFileSPrintFunc is a simple helper for PipeFsFileSFunc

func FsFoldDaisy ¶

func FsFoldDaisy(inp <-chan *fs.FsFold, tube FsFoldTube) (out <-chan *fs.FsFold)

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

func FsFoldDaisyChain ¶

func FsFoldDaisyChain(inp <-chan *fs.FsFold, tubes ...FsFoldTube) (out <-chan *fs.FsFold)

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

func FsFoldPrintFunc ¶

func FsFoldPrintFunc(prefix string) func(fp *fs.FsFold) *fs.FsFold

FsFoldPrintFunc is a simple helper for PipeFsFoldFunc

func FsFoldSDaisy ¶

func FsFoldSDaisy(inp <-chan fs.FsFoldS, tube FsFoldSTube) (out <-chan fs.FsFoldS)

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

func FsFoldSDaisyChain ¶

func FsFoldSDaisyChain(inp <-chan fs.FsFoldS, tubes ...FsFoldSTube) (out <-chan fs.FsFoldS)

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

func FsFoldSPrintFunc ¶

func FsFoldSPrintFunc(prefix string) func(fp fs.FsFoldS) fs.FsFoldS

FsFoldSPrintFunc is a simple helper for PipeFsFoldSFunc

func FsInfoSDaisy ¶

func FsInfoSDaisy(inp <-chan fs.FsInfoS, tube FsInfoSTube) (out <-chan fs.FsInfoS)

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

func FsInfoSDaisyChain ¶

func FsInfoSDaisyChain(inp <-chan fs.FsInfoS, tubes ...FsInfoSTube) (out <-chan fs.FsInfoS)

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

func FsInfoSPrintFunc ¶

func FsInfoSPrintFunc(prefix string) func(fp fs.FsInfoS) fs.FsInfoS

FsInfoSPrintFunc is a simple helper for PipeFsInfoSFunc

func FsPathSDaisy ¶

func FsPathSDaisy(inp <-chan fs.FsPathS, tube FsPathSTube) (out <-chan fs.FsPathS)

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

func FsPathSDaisyChain ¶

func FsPathSDaisyChain(inp <-chan fs.FsPathS, tubes ...FsPathSTube) (out <-chan fs.FsPathS)

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

func FsPathSPrintFunc ¶

func FsPathSPrintFunc(prefix string) func(fp fs.FsPathS) fs.FsPathS

FsPathSPrintFunc is a simple helper for PipeFsPathSFunc

func JoinFsBase ¶

func JoinFsBase(out chan<- *fs.FsBase, inp ...*fs.FsBase) (done <-chan struct{})

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

func JoinFsBaseChan ¶

func JoinFsBaseChan(out chan<- *fs.FsBase, inp <-chan *fs.FsBase) (done <-chan struct{})

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

func JoinFsBaseS ¶

func JoinFsBaseS(out chan<- fs.FsBaseS, inp ...fs.FsBaseS) (done <-chan struct{})

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

func JoinFsBaseSChan ¶

func JoinFsBaseSChan(out chan<- fs.FsBaseS, inp <-chan fs.FsBaseS) (done <-chan struct{})

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

func JoinFsBaseSSlice ¶

func JoinFsBaseSSlice(out chan<- fs.FsBaseS, inp ...[]fs.FsBaseS) (done <-chan struct{})

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

func JoinFsBaseSlice ¶

func JoinFsBaseSlice(out chan<- *fs.FsBase, inp ...[]*fs.FsBase) (done <-chan struct{})

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

func JoinFsData ¶

func JoinFsData(out chan<- *fs.FsData, inp ...*fs.FsData) (done <-chan struct{})

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

func JoinFsDataChan ¶

func JoinFsDataChan(out chan<- *fs.FsData, inp <-chan *fs.FsData) (done <-chan struct{})

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

func JoinFsDataS ¶

func JoinFsDataS(out chan<- fs.FsDataS, inp ...fs.FsDataS) (done <-chan struct{})

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

func JoinFsDataSChan ¶

func JoinFsDataSChan(out chan<- fs.FsDataS, inp <-chan fs.FsDataS) (done <-chan struct{})

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

func JoinFsDataSSlice ¶

func JoinFsDataSSlice(out chan<- fs.FsDataS, inp ...[]fs.FsDataS) (done <-chan struct{})

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

func JoinFsDataSlice ¶

func JoinFsDataSlice(out chan<- *fs.FsData, inp ...[]*fs.FsData) (done <-chan struct{})

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

func JoinFsFile ¶

func JoinFsFile(out chan<- *fs.FsFile, inp ...*fs.FsFile) (done <-chan struct{})

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

func JoinFsFileChan ¶

func JoinFsFileChan(out chan<- *fs.FsFile, inp <-chan *fs.FsFile) (done <-chan struct{})

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

func JoinFsFileS ¶

func JoinFsFileS(out chan<- fs.FsFileS, inp ...fs.FsFileS) (done <-chan struct{})

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

func JoinFsFileSChan ¶

func JoinFsFileSChan(out chan<- fs.FsFileS, inp <-chan fs.FsFileS) (done <-chan struct{})

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

func JoinFsFileSSlice ¶

func JoinFsFileSSlice(out chan<- fs.FsFileS, inp ...[]fs.FsFileS) (done <-chan struct{})

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

func JoinFsFileSlice ¶

func JoinFsFileSlice(out chan<- *fs.FsFile, inp ...[]*fs.FsFile) (done <-chan struct{})

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

func JoinFsFold ¶

func JoinFsFold(out chan<- *fs.FsFold, inp ...*fs.FsFold) (done <-chan struct{})

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

func JoinFsFoldChan ¶

func JoinFsFoldChan(out chan<- *fs.FsFold, inp <-chan *fs.FsFold) (done <-chan struct{})

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

func JoinFsFoldS ¶

func JoinFsFoldS(out chan<- fs.FsFoldS, inp ...fs.FsFoldS) (done <-chan struct{})

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

func JoinFsFoldSChan ¶

func JoinFsFoldSChan(out chan<- fs.FsFoldS, inp <-chan fs.FsFoldS) (done <-chan struct{})

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

func JoinFsFoldSSlice ¶

func JoinFsFoldSSlice(out chan<- fs.FsFoldS, inp ...[]fs.FsFoldS) (done <-chan struct{})

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

func JoinFsFoldSlice ¶

func JoinFsFoldSlice(out chan<- *fs.FsFold, inp ...[]*fs.FsFold) (done <-chan struct{})

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

func JoinFsInfoS ¶

func JoinFsInfoS(out chan<- fs.FsInfoS, inp ...fs.FsInfoS) (done <-chan struct{})

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

func JoinFsInfoSChan ¶

func JoinFsInfoSChan(out chan<- fs.FsInfoS, inp <-chan fs.FsInfoS) (done <-chan struct{})

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

func JoinFsInfoSSlice ¶

func JoinFsInfoSSlice(out chan<- fs.FsInfoS, inp ...[]fs.FsInfoS) (done <-chan struct{})

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

func JoinFsPathS ¶

func JoinFsPathS(out chan<- fs.FsPathS, inp ...fs.FsPathS) (done <-chan struct{})

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

func JoinFsPathSChan ¶

func JoinFsPathSChan(out chan<- fs.FsPathS, inp <-chan fs.FsPathS) (done <-chan struct{})

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

func JoinFsPathSSlice ¶

func JoinFsPathSSlice(out chan<- fs.FsPathS, inp ...[]fs.FsPathS) (done <-chan struct{})

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

func JoinPattern ¶

func JoinPattern(out chan<- *fs.Pattern, inp ...*fs.Pattern) (done <-chan struct{})

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

func JoinPatternChan ¶

func JoinPatternChan(out chan<- *fs.Pattern, inp <-chan *fs.Pattern) (done <-chan struct{})

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

func JoinPatternS ¶

func JoinPatternS(out chan<- fs.PatternS, inp ...fs.PatternS) (done <-chan struct{})

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

func JoinPatternSChan ¶

func JoinPatternSChan(out chan<- fs.PatternS, inp <-chan fs.PatternS) (done <-chan struct{})

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

func JoinPatternSSlice ¶

func JoinPatternSSlice(out chan<- fs.PatternS, inp ...[]fs.PatternS) (done <-chan struct{})

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

func JoinPatternSlice ¶

func JoinPatternSlice(out chan<- *fs.Pattern, inp ...[]*fs.Pattern) (done <-chan struct{})

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

func MakeFsBaseChan ¶

func MakeFsBaseChan() (out chan *fs.FsBase)

MakeFsBaseChan returns a new open channel (simply a 'chan *fs.FsBase' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsBaseSChan ¶

func MakeFsBaseSChan() (out chan fs.FsBaseS)

MakeFsBaseSChan returns a new open channel (simply a 'chan fs.FsBaseS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsDataChan ¶

func MakeFsDataChan() (out chan *fs.FsData)

MakeFsDataChan returns a new open channel (simply a 'chan *fs.FsData' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsDataSChan ¶

func MakeFsDataSChan() (out chan fs.FsDataS)

MakeFsDataSChan returns a new open channel (simply a 'chan fs.FsDataS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsFileChan ¶

func MakeFsFileChan() (out chan *fs.FsFile)

MakeFsFileChan returns a new open channel (simply a 'chan *fs.FsFile' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsFileSChan ¶

func MakeFsFileSChan() (out chan fs.FsFileS)

MakeFsFileSChan returns a new open channel (simply a 'chan fs.FsFileS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsFoldChan ¶

func MakeFsFoldChan() (out chan *fs.FsFold)

MakeFsFoldChan returns a new open channel (simply a 'chan *fs.FsFold' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsFoldSChan ¶

func MakeFsFoldSChan() (out chan fs.FsFoldS)

MakeFsFoldSChan returns a new open channel (simply a 'chan fs.FsFoldS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsInfoSChan ¶

func MakeFsInfoSChan() (out chan fs.FsInfoS)

MakeFsInfoSChan returns a new open channel (simply a 'chan fs.FsInfoS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakeFsPathSChan ¶

func MakeFsPathSChan() (out chan fs.FsPathS)

MakeFsPathSChan returns a new open channel (simply a 'chan fs.FsPathS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakePatternChan ¶

func MakePatternChan() (out chan *fs.Pattern)

MakePatternChan returns a new open channel (simply a 'chan *fs.Pattern' that is).

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

This is useful to easily create corresponding variables such as

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

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

func MakePatternSChan ¶

func MakePatternSChan() (out chan fs.PatternS)

MakePatternSChan returns a new open channel (simply a 'chan fs.PatternS' that is).

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

This is useful to easily create corresponding variables such as

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

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

func PatternDaisy ¶

func PatternDaisy(inp <-chan *fs.Pattern, tube PatternTube) (out <-chan *fs.Pattern)

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

func PatternDaisyChain ¶

func PatternDaisyChain(inp <-chan *fs.Pattern, tubes ...PatternTube) (out <-chan *fs.Pattern)

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

func PatternPrintFunc ¶

func PatternPrintFunc(prefix string) func(fp *fs.Pattern) *fs.Pattern

PatternPrintFunc is a simple helper for PipePatternFunc

func PatternSDaisy ¶

func PatternSDaisy(inp <-chan fs.PatternS, tube PatternSTube) (out <-chan fs.PatternS)

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

func PatternSDaisyChain ¶

func PatternSDaisyChain(inp <-chan fs.PatternS, tubes ...PatternSTube) (out <-chan fs.PatternS)

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

func PatternSPrintFunc ¶

func PatternSPrintFunc(prefix string) func(fp fs.PatternS) fs.PatternS

PatternSPrintFunc is a simple helper for PipePatternSFunc

func PipeFsBaseBuffer ¶

func PipeFsBaseBuffer(inp <-chan *fs.FsBase, cap int) (out <-chan *fs.FsBase)

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

func PipeFsBaseFork ¶

func PipeFsBaseFork(inp <-chan *fs.FsBase) (out1, out2 <-chan *fs.FsBase)

PipeFsBaseFork 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 PipeFsBaseFunc ¶

func PipeFsBaseFunc(inp <-chan *fs.FsBase, act func(a *fs.FsBase) *fs.FsBase) (out <-chan *fs.FsBase)

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

func PipeFsBaseSBuffer ¶

func PipeFsBaseSBuffer(inp <-chan fs.FsBaseS, cap int) (out <-chan fs.FsBaseS)

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

func PipeFsBaseSFork ¶

func PipeFsBaseSFork(inp <-chan fs.FsBaseS) (out1, out2 <-chan fs.FsBaseS)

PipeFsBaseSFork 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 PipeFsBaseSFunc ¶

func PipeFsBaseSFunc(inp <-chan fs.FsBaseS, act func(a fs.FsBaseS) fs.FsBaseS) (out <-chan fs.FsBaseS)

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

func PipeFsDataBuffer ¶

func PipeFsDataBuffer(inp <-chan *fs.FsData, cap int) (out <-chan *fs.FsData)

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

func PipeFsDataFork ¶

func PipeFsDataFork(inp <-chan *fs.FsData) (out1, out2 <-chan *fs.FsData)

PipeFsDataFork 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 PipeFsDataFunc ¶

func PipeFsDataFunc(inp <-chan *fs.FsData, act func(a *fs.FsData) *fs.FsData) (out <-chan *fs.FsData)

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

func PipeFsDataSBuffer ¶

func PipeFsDataSBuffer(inp <-chan fs.FsDataS, cap int) (out <-chan fs.FsDataS)

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

func PipeFsDataSFork ¶

func PipeFsDataSFork(inp <-chan fs.FsDataS) (out1, out2 <-chan fs.FsDataS)

PipeFsDataSFork 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 PipeFsDataSFunc ¶

func PipeFsDataSFunc(inp <-chan fs.FsDataS, act func(a fs.FsDataS) fs.FsDataS) (out <-chan fs.FsDataS)

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

func PipeFsFileBuffer ¶

func PipeFsFileBuffer(inp <-chan *fs.FsFile, cap int) (out <-chan *fs.FsFile)

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

func PipeFsFileFork ¶

func PipeFsFileFork(inp <-chan *fs.FsFile) (out1, out2 <-chan *fs.FsFile)

PipeFsFileFork 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 PipeFsFileFunc ¶

func PipeFsFileFunc(inp <-chan *fs.FsFile, act func(a *fs.FsFile) *fs.FsFile) (out <-chan *fs.FsFile)

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

func PipeFsFileGlob ¶

func PipeFsFileGlob(
	inp <-chan fs.FsFile,
	dirS chan<- fs.FsFold,
	filS chan<- fs.FsFile) (
	out <-chan struct{})

PipeFsFileGlob forks received fsfiles into directories and files according to fs.MatchDisk

func PipeFsFileSBuffer ¶

func PipeFsFileSBuffer(inp <-chan fs.FsFileS, cap int) (out <-chan fs.FsFileS)

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

func PipeFsFileSFork ¶

func PipeFsFileSFork(inp <-chan fs.FsFileS) (out1, out2 <-chan fs.FsFileS)

PipeFsFileSFork 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 PipeFsFileSFunc ¶

func PipeFsFileSFunc(inp <-chan fs.FsFileS, act func(a fs.FsFileS) fs.FsFileS) (out <-chan fs.FsFileS)

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

func PipeFsFoldBuffer ¶

func PipeFsFoldBuffer(inp <-chan *fs.FsFold, cap int) (out <-chan *fs.FsFold)

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

func PipeFsFoldFork ¶

func PipeFsFoldFork(inp <-chan *fs.FsFold) (out1, out2 <-chan *fs.FsFold)

PipeFsFoldFork 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 PipeFsFoldFunc ¶

func PipeFsFoldFunc(inp <-chan *fs.FsFold, act func(a *fs.FsFold) *fs.FsFold) (out <-chan *fs.FsFold)

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

func PipeFsFoldSBuffer ¶

func PipeFsFoldSBuffer(inp <-chan fs.FsFoldS, cap int) (out <-chan fs.FsFoldS)

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

func PipeFsFoldSFork ¶

func PipeFsFoldSFork(inp <-chan fs.FsFoldS) (out1, out2 <-chan fs.FsFoldS)

PipeFsFoldSFork 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 PipeFsFoldSFunc ¶

func PipeFsFoldSFunc(inp <-chan fs.FsFoldS, act func(a fs.FsFoldS) fs.FsFoldS) (out <-chan fs.FsFoldS)

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

func PipeFsInfoSBuffer ¶

func PipeFsInfoSBuffer(inp <-chan fs.FsInfoS, cap int) (out <-chan fs.FsInfoS)

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

func PipeFsInfoSFork ¶

func PipeFsInfoSFork(inp <-chan fs.FsInfoS) (out1, out2 <-chan fs.FsInfoS)

PipeFsInfoSFork 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 PipeFsInfoSFunc ¶

func PipeFsInfoSFunc(inp <-chan fs.FsInfoS, act func(a fs.FsInfoS) fs.FsInfoS) (out <-chan fs.FsInfoS)

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

func PipeFsPathSBuffer ¶

func PipeFsPathSBuffer(inp <-chan fs.FsPathS, cap int) (out <-chan fs.FsPathS)

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

func PipeFsPathSFork ¶

func PipeFsPathSFork(inp <-chan fs.FsPathS) (out1, out2 <-chan fs.FsPathS)

PipeFsPathSFork 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 PipeFsPathSFunc ¶

func PipeFsPathSFunc(inp <-chan fs.FsPathS, act func(a fs.FsPathS) fs.FsPathS) (out <-chan fs.FsPathS)

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

func PipePatternBuffer ¶

func PipePatternBuffer(inp <-chan *fs.Pattern, cap int) (out <-chan *fs.Pattern)

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

func PipePatternFork ¶

func PipePatternFork(inp <-chan *fs.Pattern) (out1, out2 <-chan *fs.Pattern)

PipePatternFork 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 PipePatternFunc ¶

func PipePatternFunc(inp <-chan *fs.Pattern, act func(a *fs.Pattern) *fs.Pattern) (out <-chan *fs.Pattern)

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

func PipePatternSBuffer ¶

func PipePatternSBuffer(inp <-chan fs.PatternS, cap int) (out <-chan fs.PatternS)

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

func PipePatternSFork ¶

func PipePatternSFork(inp <-chan fs.PatternS) (out1, out2 <-chan fs.PatternS)

PipePatternSFork 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 PipePatternSFunc ¶

func PipePatternSFunc(inp <-chan fs.PatternS, act func(a fs.PatternS) fs.PatternS) (out <-chan fs.PatternS)

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

func SendProxyFsBase ¶

func SendProxyFsBase(out chan<- *fs.FsBase) chan<- *fs.FsBase

SendProxyFsBase 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 SendProxyFsBaseS ¶

func SendProxyFsBaseS(out chan<- fs.FsBaseS) chan<- fs.FsBaseS

SendProxyFsBaseS 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 SendProxyFsData ¶

func SendProxyFsData(out chan<- *fs.FsData) chan<- *fs.FsData

SendProxyFsData 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 SendProxyFsDataS ¶

func SendProxyFsDataS(out chan<- fs.FsDataS) chan<- fs.FsDataS

SendProxyFsDataS 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 SendProxyFsFile ¶

func SendProxyFsFile(out chan<- *fs.FsFile) chan<- *fs.FsFile

SendProxyFsFile 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 SendProxyFsFileS ¶

func SendProxyFsFileS(out chan<- fs.FsFileS) chan<- fs.FsFileS

SendProxyFsFileS 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 SendProxyFsFold ¶

func SendProxyFsFold(out chan<- *fs.FsFold) chan<- *fs.FsFold

SendProxyFsFold 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 SendProxyFsFoldS ¶

func SendProxyFsFoldS(out chan<- fs.FsFoldS) chan<- fs.FsFoldS

SendProxyFsFoldS 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 SendProxyFsInfoS ¶

func SendProxyFsInfoS(out chan<- fs.FsInfoS) chan<- fs.FsInfoS

SendProxyFsInfoS 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 SendProxyFsPathS ¶

func SendProxyFsPathS(out chan<- fs.FsPathS) chan<- fs.FsPathS

SendProxyFsPathS 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 SendProxyPattern ¶

func SendProxyPattern(out chan<- *fs.Pattern) chan<- *fs.Pattern

SendProxyPattern 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 SendProxyPatternS ¶

func SendProxyPatternS(out chan<- fs.PatternS) chan<- fs.PatternS

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