bufio

Documentation

Index

• func PipeLines(inp <-chan os.File) (out <-chan string)
• func ReadWriters(inp1 <-chan *bufio.Reader, inp2 <-chan *bufio.Writer) (out <-chan *bufio.ReadWriter)
• func ReaderSize(inp <-chan io.Reader, size int) (out <-chan *bufio.Reader)
• func Readers(inp <-chan io.Reader) (out <-chan *bufio.Reader)
• func Scanners(inp <-chan io.Reader) (out <-chan *bufio.Scanner)
• func WriterSize(inp <-chan io.Writer, size int) (out <-chan *bufio.Writer)
• func Writers(inp <-chan io.Writer) (out <-chan *bufio.Writer)
• type DChReadWriter
  • func MakeDemandReadWriterBuff(cap int) *DChReadWriter
  • func MakeDemandReadWriterChan() *DChReadWriter
  • func (c *DChReadWriter) ProvideReadWriter(dat *bufio.ReadWriter)
  • func (c *DChReadWriter) RequestReadWriter() (dat *bufio.ReadWriter)
  • func (c *DChReadWriter) TryReadWriter() (dat *bufio.ReadWriter, open bool)
• type DChReader
  • func MakeDemandReaderBuff(cap int) *DChReader
  • func MakeDemandReaderChan() *DChReader
  • func (c *DChReader) ProvideReader(dat *bufio.Reader)
  • func (c *DChReader) RequestReader() (dat *bufio.Reader)
  • func (c *DChReader) TryReader() (dat *bufio.Reader, open bool)
• type DChScanner
  • func MakeDemandScannerBuff(cap int) *DChScanner
  • func MakeDemandScannerChan() *DChScanner
  • func (c *DChScanner) ProvideScanner(dat *bufio.Scanner)
  • func (c *DChScanner) RequestScanner() (dat *bufio.Scanner)
  • func (c *DChScanner) TryScanner() (dat *bufio.Scanner, open bool)
• type DChSplitFunc
  • func MakeDemandSplitFuncBuff(cap int) *DChSplitFunc
  • func MakeDemandSplitFuncChan() *DChSplitFunc
  • func (c *DChSplitFunc) ProvideSplitFunc(dat bufio.SplitFunc)
  • func (c *DChSplitFunc) RequestSplitFunc() (dat bufio.SplitFunc)
  • func (c *DChSplitFunc) TrySplitFunc() (dat bufio.SplitFunc, open bool)
• type DChWriter
  • func MakeDemandWriterBuff(cap int) *DChWriter
  • func MakeDemandWriterChan() *DChWriter
  • func (c *DChWriter) ProvideWriter(dat *bufio.Writer)
  • func (c *DChWriter) RequestWriter() (dat *bufio.Writer)
  • func (c *DChWriter) TryWriter() (dat *bufio.Writer, open bool)
• type ReadWriterChan
• type ReadWriterROnlyChan
• type ReadWriterSOnlyChan
• type ReaderChan
• type ReaderROnlyChan
• type ReaderSOnlyChan
• type ScannerChan
• type ScannerROnlyChan
• type ScannerSOnlyChan
• type SplitFuncChan
• type SplitFuncROnlyChan
• type SplitFuncSOnlyChan
• type WriterChan
• type WriterROnlyChan
• type WriterSOnlyChan

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