bufio

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PipeLines 

func PipeLines(inp <-chan os.File) (out <-chan string)

PipeLines - an experiment

func ReadWriters 

func ReadWriters(inp1 <-chan *bufio.Reader, inp2 <-chan *bufio.Writer) (out <-chan *bufio.ReadWriter)

ReadWriters - (r *Reader, w *Writer) *ReadWriter

func ReaderSize 

func ReaderSize(inp <-chan io.Reader, size int) (out <-chan *bufio.Reader)

ReaderSize - (w io.Reader, size int) *Reader

func Readers 

func Readers(inp <-chan io.Reader) (out <-chan *bufio.Reader)

Readers - (w io.Reader) *Reader

func Scanners 

func Scanners(inp <-chan io.Reader) (out <-chan *bufio.Scanner)

Scanners - (r io.Reader) *Scanner

func WriterSize 

func WriterSize(inp <-chan io.Writer, size int) (out <-chan *bufio.Writer)

WriterSize - (w io.Writer, size int) *Writer

func Writers 

func Writers(inp <-chan io.Writer) (out <-chan *bufio.Writer)

Writers - (w io.Writer) *Writer

Types

type DChReadWriter 

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

DChReadWriter is a demand channel

func MakeDemandReadWriterBuff 

func MakeDemandReadWriterBuff(cap int) *DChReadWriter

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

func MakeDemandReadWriterChan 

func MakeDemandReadWriterChan() *DChReadWriter

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

func (*DChReadWriter) ProvideReadWriter 

func (c *DChReadWriter) ProvideReadWriter(dat *bufio.ReadWriter)

ProvideReadWriter is the send function - aka "MyKind <- some ReadWriter"

func (*DChReadWriter) RequestReadWriter 

func (c *DChReadWriter) RequestReadWriter() (dat *bufio.ReadWriter)

RequestReadWriter is the receive function - aka "some ReadWriter <- MyKind"

func (*DChReadWriter) TryReadWriter 

func (c *DChReadWriter) TryReadWriter() (dat *bufio.ReadWriter, open bool)

TryReadWriter is the comma-ok multi-valued form of RequestReadWriter and reports whether a received value was sent before the ReadWriter channel was closed.

type DChReader 

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

DChReader is a demand channel

func MakeDemandReaderBuff 

func MakeDemandReaderBuff(cap int) *DChReader

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

func MakeDemandReaderChan 

func MakeDemandReaderChan() *DChReader

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

func (*DChReader) ProvideReader 

func (c *DChReader) ProvideReader(dat *bufio.Reader)

ProvideReader is the send function - aka "MyKind <- some Reader"

func (*DChReader) RequestReader 

func (c *DChReader) RequestReader() (dat *bufio.Reader)

RequestReader is the receive function - aka "some Reader <- MyKind"

func (*DChReader) TryReader 

func (c *DChReader) TryReader() (dat *bufio.Reader, open bool)

TryReader is the comma-ok multi-valued form of RequestReader and reports whether a received value was sent before the Reader channel was closed.

type DChScanner 

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

DChScanner is a demand channel

func MakeDemandScannerBuff 

func MakeDemandScannerBuff(cap int) *DChScanner

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

func MakeDemandScannerChan 

func MakeDemandScannerChan() *DChScanner

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

func (*DChScanner) ProvideScanner 

func (c *DChScanner) ProvideScanner(dat *bufio.Scanner)

ProvideScanner is the send function - aka "MyKind <- some Scanner"

func (*DChScanner) RequestScanner 

func (c *DChScanner) RequestScanner() (dat *bufio.Scanner)

RequestScanner is the receive function - aka "some Scanner <- MyKind"

func (*DChScanner) TryScanner 

func (c *DChScanner) TryScanner() (dat *bufio.Scanner, open bool)

TryScanner is the comma-ok multi-valued form of RequestScanner and reports whether a received value was sent before the Scanner channel was closed.

type DChSplitFunc 

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

DChSplitFunc is a demand channel

func MakeDemandSplitFuncBuff 

func MakeDemandSplitFuncBuff(cap int) *DChSplitFunc

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

func MakeDemandSplitFuncChan 

func MakeDemandSplitFuncChan() *DChSplitFunc

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

func (*DChSplitFunc) ProvideSplitFunc 

func (c *DChSplitFunc) ProvideSplitFunc(dat bufio.SplitFunc)

ProvideSplitFunc is the send function - aka "MyKind <- some SplitFunc"

func (*DChSplitFunc) RequestSplitFunc 

func (c *DChSplitFunc) RequestSplitFunc() (dat bufio.SplitFunc)

RequestSplitFunc is the receive function - aka "some SplitFunc <- MyKind"

func (*DChSplitFunc) TrySplitFunc 

func (c *DChSplitFunc) TrySplitFunc() (dat bufio.SplitFunc, open bool)

TrySplitFunc is the comma-ok multi-valued form of RequestSplitFunc and reports whether a received value was sent before the SplitFunc channel was closed.

type DChWriter 

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

DChWriter is a demand channel

func MakeDemandWriterBuff 

func MakeDemandWriterBuff(cap int) *DChWriter

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

func MakeDemandWriterChan 

func MakeDemandWriterChan() *DChWriter

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

func (*DChWriter) ProvideWriter 

func (c *DChWriter) ProvideWriter(dat *bufio.Writer)

ProvideWriter is the send function - aka "MyKind <- some Writer"

func (*DChWriter) RequestWriter 

func (c *DChWriter) RequestWriter() (dat *bufio.Writer)

RequestWriter is the receive function - aka "some Writer <- MyKind"

func (*DChWriter) TryWriter 

func (c *DChWriter) TryWriter() (dat *bufio.Writer, open bool)

TryWriter is the comma-ok multi-valued form of RequestWriter and reports whether a received value was sent before the Writer channel was closed.

type ReadWriterChan 

type ReadWriterChan interface {
	ReadWriterROnlyChan // aka "<-chan" - receive only
	ReadWriterSOnlyChan // aka "chan<-" - send only
}

ReadWriterChan represents a bidirectional channel

type ReadWriterROnlyChan 

type ReadWriterROnlyChan interface {
	RequestReadWriter() (dat *bufio.ReadWriter)        // the receive function - aka "MyReadWriter := <-MyReadWriterROnlyChan"
	TryReadWriter() (dat *bufio.ReadWriter, open bool) // the multi-valued comma-ok receive function - aka "MyReadWriter, ok := <-MyReadWriterROnlyChan"
}

ReadWriterROnlyChan represents a receive-only channel

type ReadWriterSOnlyChan 

type ReadWriterSOnlyChan interface {
	ProvideReadWriter(dat *bufio.ReadWriter) // the send function - aka "MyKind <- some ReadWriter"
}

ReadWriterSOnlyChan represents a send-only channel

type ReaderChan 

type ReaderChan interface {
	ReaderROnlyChan // aka "<-chan" - receive only
	ReaderSOnlyChan // aka "chan<-" - send only
}

ReaderChan represents a bidirectional channel

type ReaderROnlyChan 

type ReaderROnlyChan interface {
	RequestReader() (dat *bufio.Reader)        // the receive function - aka "MyReader := <-MyReaderROnlyChan"
	TryReader() (dat *bufio.Reader, open bool) // the multi-valued comma-ok receive function - aka "MyReader, ok := <-MyReaderROnlyChan"
}

ReaderROnlyChan represents a receive-only channel

type ReaderSOnlyChan 

type ReaderSOnlyChan interface {
	ProvideReader(dat *bufio.Reader) // the send function - aka "MyKind <- some Reader"
}

ReaderSOnlyChan represents a send-only channel

type SChReadWriter 

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

SChReadWriter is a supply channel

func MakeSupplyReadWriterBuff 

func MakeSupplyReadWriterBuff(cap int) *SChReadWriter

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

func MakeSupplyReadWriterChan 

func MakeSupplyReadWriterChan() *SChReadWriter

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

func (*SChReadWriter) ProvideReadWriter 

func (c *SChReadWriter) ProvideReadWriter(dat *bufio.ReadWriter)

ProvideReadWriter is the send function - aka "MyKind <- some ReadWriter"

func (*SChReadWriter) RequestReadWriter 

func (c *SChReadWriter) RequestReadWriter() (dat *bufio.ReadWriter)

RequestReadWriter is the receive function - aka "some ReadWriter <- MyKind"

func (*SChReadWriter) TryReadWriter 

func (c *SChReadWriter) TryReadWriter() (dat *bufio.ReadWriter, open bool)

TryReadWriter is the comma-ok multi-valued form of RequestReadWriter and reports whether a received value was sent before the ReadWriter channel was closed.

type SChReader 

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

SChReader is a supply channel

func MakeSupplyReaderBuff 

func MakeSupplyReaderBuff(cap int) *SChReader

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

func MakeSupplyReaderChan 

func MakeSupplyReaderChan() *SChReader

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

func (*SChReader) ProvideReader 

func (c *SChReader) ProvideReader(dat *bufio.Reader)

ProvideReader is the send function - aka "MyKind <- some Reader"

func (*SChReader) RequestReader 

func (c *SChReader) RequestReader() (dat *bufio.Reader)

RequestReader is the receive function - aka "some Reader <- MyKind"

func (*SChReader) TryReader 

func (c *SChReader) TryReader() (dat *bufio.Reader, open bool)

TryReader is the comma-ok multi-valued form of RequestReader and reports whether a received value was sent before the Reader channel was closed.

type SChScanner 

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

SChScanner is a supply channel

func MakeSupplyScannerBuff 

func MakeSupplyScannerBuff(cap int) *SChScanner

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

func MakeSupplyScannerChan 

func MakeSupplyScannerChan() *SChScanner

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

func (*SChScanner) ProvideScanner 

func (c *SChScanner) ProvideScanner(dat *bufio.Scanner)

ProvideScanner is the send function - aka "MyKind <- some Scanner"

func (*SChScanner) RequestScanner 

func (c *SChScanner) RequestScanner() (dat *bufio.Scanner)

RequestScanner is the receive function - aka "some Scanner <- MyKind"

func (*SChScanner) TryScanner 

func (c *SChScanner) TryScanner() (dat *bufio.Scanner, open bool)

TryScanner is the comma-ok multi-valued form of RequestScanner and reports whether a received value was sent before the Scanner channel was closed.

type SChSplitFunc 

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

SChSplitFunc is a supply channel

func MakeSupplySplitFuncBuff 

func MakeSupplySplitFuncBuff(cap int) *SChSplitFunc

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

func MakeSupplySplitFuncChan 

func MakeSupplySplitFuncChan() *SChSplitFunc

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

func (*SChSplitFunc) ProvideSplitFunc 

func (c *SChSplitFunc) ProvideSplitFunc(dat bufio.SplitFunc)

ProvideSplitFunc is the send function - aka "MyKind <- some SplitFunc"

func (*SChSplitFunc) RequestSplitFunc 

func (c *SChSplitFunc) RequestSplitFunc() (dat bufio.SplitFunc)

RequestSplitFunc is the receive function - aka "some SplitFunc <- MyKind"

func (*SChSplitFunc) TrySplitFunc 

func (c *SChSplitFunc) TrySplitFunc() (dat bufio.SplitFunc, open bool)

TrySplitFunc is the comma-ok multi-valued form of RequestSplitFunc and reports whether a received value was sent before the SplitFunc channel was closed.

type SChWriter 

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

SChWriter is a supply channel

func MakeSupplyWriterBuff 

func MakeSupplyWriterBuff(cap int) *SChWriter

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

func MakeSupplyWriterChan 

func MakeSupplyWriterChan() *SChWriter

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

func (*SChWriter) ProvideWriter 

func (c *SChWriter) ProvideWriter(dat *bufio.Writer)

ProvideWriter is the send function - aka "MyKind <- some Writer"

func (*SChWriter) RequestWriter 

func (c *SChWriter) RequestWriter() (dat *bufio.Writer)

RequestWriter is the receive function - aka "some Writer <- MyKind"

func (*SChWriter) TryWriter 

func (c *SChWriter) TryWriter() (dat *bufio.Writer, open bool)

TryWriter is the comma-ok multi-valued form of RequestWriter and reports whether a received value was sent before the Writer channel was closed.

type ScannerChan 

type ScannerChan interface {
	ScannerROnlyChan // aka "<-chan" - receive only
	ScannerSOnlyChan // aka "chan<-" - send only
}

ScannerChan represents a bidirectional channel

type ScannerROnlyChan 

type ScannerROnlyChan interface {
	RequestScanner() (dat *bufio.Scanner)        // the receive function - aka "MyScanner := <-MyScannerROnlyChan"
	TryScanner() (dat *bufio.Scanner, open bool) // the multi-valued comma-ok receive function - aka "MyScanner, ok := <-MyScannerROnlyChan"
}

ScannerROnlyChan represents a receive-only channel

type ScannerSOnlyChan 

type ScannerSOnlyChan interface {
	ProvideScanner(dat *bufio.Scanner) // the send function - aka "MyKind <- some Scanner"
}

ScannerSOnlyChan represents a send-only channel

type SplitFuncChan 

type SplitFuncChan interface {
	SplitFuncROnlyChan // aka "<-chan" - receive only
	SplitFuncSOnlyChan // aka "chan<-" - send only
}

SplitFuncChan represents a bidirectional channel

type SplitFuncROnlyChan 

type SplitFuncROnlyChan interface {
	RequestSplitFunc() (dat bufio.SplitFunc)        // the receive function - aka "MySplitFunc := <-MySplitFuncROnlyChan"
	TrySplitFunc() (dat bufio.SplitFunc, open bool) // the multi-valued comma-ok receive function - aka "MySplitFunc, ok := <-MySplitFuncROnlyChan"
}

SplitFuncROnlyChan represents a receive-only channel

type SplitFuncSOnlyChan 

type SplitFuncSOnlyChan interface {
	ProvideSplitFunc(dat bufio.SplitFunc) // the send function - aka "MyKind <- some SplitFunc"
}

SplitFuncSOnlyChan represents a send-only channel

type WriterChan 

type WriterChan interface {
	WriterROnlyChan // aka "<-chan" - receive only
	WriterSOnlyChan // aka "chan<-" - send only
}

WriterChan represents a bidirectional channel

type WriterROnlyChan 

type WriterROnlyChan interface {
	RequestWriter() (dat *bufio.Writer)        // the receive function - aka "MyWriter := <-MyWriterROnlyChan"
	TryWriter() (dat *bufio.Writer, open bool) // the multi-valued comma-ok receive function - aka "MyWriter, ok := <-MyWriterROnlyChan"
}

WriterROnlyChan represents a receive-only channel

type WriterSOnlyChan 

type WriterSOnlyChan interface {
	ProvideWriter(dat *bufio.Writer) // the send function - aka "MyKind <- some Writer"
}

WriterSOnlyChan represents a send-only channel

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.