os

Documentation

Index

• type FileChan
• type FileInfoChan
• type FileInfoROnlyChan
• type FileInfoSOnlyChan
• type FileROnlyChan
• type FileSOnlyChan
• type SChFile
  • func MakeSupplyFileBuff(cap int) *SChFile
  • func MakeSupplyFileChan() *SChFile
  • func (c *SChFile) ProvideFile(dat *os.File)
  • func (c *SChFile) RequestFile() (dat *os.File)
  • func (c *SChFile) TryFile() (dat *os.File, open bool)
• type SChFileInfo
  • func MakeSupplyFileInfoBuff(cap int) *SChFileInfo
  • func MakeSupplyFileInfoChan() *SChFileInfo
  • func (c *SChFileInfo) ProvideFileInfo(dat os.FileInfo)
  • func (c *SChFileInfo) RequestFileInfo() (dat os.FileInfo)
  • func (c *SChFileInfo) TryFileInfo() (dat os.FileInfo, open bool)
• type SChSignal
  • func MakeSupplySignalBuff(cap int) *SChSignal
  • func MakeSupplySignalChan() *SChSignal
  • func (c *SChSignal) ProvideSignal(dat os.Signal)
  • func (c *SChSignal) RequestSignal() (dat os.Signal)
  • func (c *SChSignal) TrySignal() (dat os.Signal, open bool)
• type SignalChan
• type SignalROnlyChan
• type SignalSOnlyChan

Types

type FileChan

type FileChan interface {
	FileROnlyChan // aka "<-chan" - receive only
	FileSOnlyChan // aka "chan<-" - send only
}

FileChan represents a bidirectional channel

type FileInfoChan

type FileInfoChan interface {
	FileInfoROnlyChan // aka "<-chan" - receive only
	FileInfoSOnlyChan // aka "chan<-" - send only
}

FileInfoChan represents a bidirectional channel

type FileInfoROnlyChan

type FileInfoROnlyChan interface {
	RequestFileInfo() (dat os.FileInfo)        // the receive function - aka "MyFileInfo := <-MyFileInfoROnlyChan"
	TryFileInfo() (dat os.FileInfo, open bool) // the multi-valued comma-ok receive function - aka "MyFileInfo, ok := <-MyFileInfoROnlyChan"
}

FileInfoROnlyChan represents a receive-only channel

type FileInfoSOnlyChan

type FileInfoSOnlyChan interface {
	ProvideFileInfo(dat os.FileInfo) // the send function - aka "MyKind <- some FileInfo"
}

FileInfoSOnlyChan represents a send-only channel

type FileROnlyChan

type FileROnlyChan interface {
	RequestFile() (dat *os.File)        // the receive function - aka "MyFile := <-MyFileROnlyChan"
	TryFile() (dat *os.File, open bool) // the multi-valued comma-ok receive function - aka "MyFile, ok := <-MyFileROnlyChan"
}

FileROnlyChan represents a receive-only channel

type FileSOnlyChan

type FileSOnlyChan interface {
	ProvideFile(dat *os.File) // the send function - aka "MyKind <- some File"
}

FileSOnlyChan represents a send-only channel

type SChFile

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

SChFile is a supply channel

func MakeSupplyFileBuff

func MakeSupplyFileBuff(cap int) *SChFile

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

func MakeSupplyFileChan

func MakeSupplyFileChan() *SChFile

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

func (*SChFile) ProvideFile

func (c *SChFile) ProvideFile(dat *os.File)

ProvideFile is the send function - aka "MyKind <- some File"

func (*SChFile) RequestFile

func (c *SChFile) RequestFile() (dat *os.File)

RequestFile is the receive function - aka "some File <- MyKind"

func (*SChFile) TryFile

func (c *SChFile) TryFile() (dat *os.File, open bool)

TryFile is the comma-ok multi-valued form of RequestFile and reports whether a received value was sent before the File channel was closed.

type SChFileInfo

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

SChFileInfo is a supply channel

func MakeSupplyFileInfoBuff

func MakeSupplyFileInfoBuff(cap int) *SChFileInfo

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

func MakeSupplyFileInfoChan

func MakeSupplyFileInfoChan() *SChFileInfo

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

func (*SChFileInfo) ProvideFileInfo

func (c *SChFileInfo) ProvideFileInfo(dat os.FileInfo)

ProvideFileInfo is the send function - aka "MyKind <- some FileInfo"

func (*SChFileInfo) RequestFileInfo

func (c *SChFileInfo) RequestFileInfo() (dat os.FileInfo)

RequestFileInfo is the receive function - aka "some FileInfo <- MyKind"

func (*SChFileInfo) TryFileInfo

func (c *SChFileInfo) TryFileInfo() (dat os.FileInfo, open bool)

TryFileInfo is the comma-ok multi-valued form of RequestFileInfo and reports whether a received value was sent before the FileInfo channel was closed.

type SChSignal

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

SChSignal is a supply channel

func MakeSupplySignalBuff

func MakeSupplySignalBuff(cap int) *SChSignal

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

func MakeSupplySignalChan

func MakeSupplySignalChan() *SChSignal

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

func (*SChSignal) ProvideSignal

func (c *SChSignal) ProvideSignal(dat os.Signal)

ProvideSignal is the send function - aka "MyKind <- some Signal"

func (*SChSignal) RequestSignal

func (c *SChSignal) RequestSignal() (dat os.Signal)

RequestSignal is the receive function - aka "some Signal <- MyKind"

func (*SChSignal) TrySignal

func (c *SChSignal) TrySignal() (dat os.Signal, open bool)

TrySignal is the comma-ok multi-valued form of RequestSignal and reports whether a received value was sent before the Signal channel was closed.

type SignalChan

type SignalChan interface {
	SignalROnlyChan // aka "<-chan" - receive only
	SignalSOnlyChan // aka "chan<-" - send only
}

SignalChan represents a bidirectional channel

type SignalROnlyChan

type SignalROnlyChan interface {
	RequestSignal() (dat os.Signal)        // the receive function - aka "MySignal := <-MySignalROnlyChan"
	TrySignal() (dat os.Signal, open bool) // the multi-valued comma-ok receive function - aka "MySignal, ok := <-MySignalROnlyChan"
}

SignalROnlyChan represents a receive-only channel

type SignalSOnlyChan

type SignalSOnlyChan interface {
	ProvideSignal(dat os.Signal) // the send function - aka "MyKind <- some Signal"
}

SignalSOnlyChan represents a send-only channel