channel

type Reader ¶

type Reader[T any] interface {
	WithContext[T]
	Read() (T, bool)
	ReadWithTimeout(time.Duration) (T, bool)
}

Reader helps in reading from channels with context.

func NewReader[T any](ctx context.Context, input <-chan T) Reader[T]

type ReaderWriter ¶

type ReaderWriter[T any] interface {
	Reader[T]
	Writer[T]
}

ReaderWriter helps in reading and writing to channels with context. It enforces a quick release pattern so a worker will stop immediately when the context is done, and won't be hanged until the channel is closed (if ever). By using the helper instead of using channels directly, we can make sure our system never hangs on channels. This is helpful for two scenarios when close(chan) can't be used:

1. We want to stop the worker even if there are still items in the channel.
2. There are multiple writers to a channel, so it is difficult to close the channel while avoiding possible panics.

func Make[T any](ctx context.Context, size int) ReaderWriter[T]

func NewReaderWriter[T any](ctx context.Context, inputOutput chan T) ReaderWriter[T]

type Ready ¶

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

Ready supports waiting for readiness and notifying of readiness. It also supports closing to release waiters.

func NewReady() *Ready

func (r *Ready) Close()

func (r *Ready) Reset()

func (r *Ready) SignalReady()

func (r *Ready) WaitForReady(ctx context.Context) bool

type WithContext ¶

type WithContext[T any] interface {
	Context() context.Context
	WithContext(ctx context.Context) ReaderWriter[T]
}

WithContext supports fetching and updating the context.

type Writer ¶

type Writer[T any] interface {
	WithContext[T]
	Write(value T) bool
}

Writer helps in writing to channels with context.

func NewWriter[T any](ctx context.Context, output chan<- T) Writer[T]