package promise

import "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise"

Index

Types

type LockingReadable 

type LockingReadable interface {
	Readable

	// GetLocked is like Get but the caller must already hold the
	// lock.  GetLocked may release, and later re-acquire, the lock
	// any number of times.  Get may acquire, and later release, the
	// lock any number of times.
	GetLocked() interface{}

	// IsSetLocked is like IsSet but the caller must already hold the
	// lock.  IsSetLocked may release, and later re-acquire, the lock
	// any number of times.  IsSet may acquire, and later release, the
	// lock any number of times.
	IsSetLocked() bool
}

LockingReadable is a Readable whose implementation is protected by a lock

type LockingWriteMultiple 

type LockingWriteMultiple interface {
	LockingReadable
	LockingWriteMultipleOnly
}

LockingWriteMultiple is a WriteMultiple whose implementation is protected by a lock.

type LockingWriteMultipleOnly 

type LockingWriteMultipleOnly interface {
	WriteMultipleOnly

	// SetLocked is like Set but the caller must already hold the
	// lock.  SetLocked may release, and later re-acquire, the lock
	// any number of times.  Set may acquire, and later release, the
	// lock any number of times
	SetLocked(interface{})
}

LockingWriteMultipleOnly is a WriteMultipleOnly whose implementation is protected by a lock.

type LockingWriteOnce 

type LockingWriteOnce interface {
	LockingReadable
	LockingWriteOnceOnly
}

LockingWriteOnce is a WriteOnce whose implementation is protected by a lock.

type LockingWriteOnceOnly 

type LockingWriteOnceOnly interface {
	WriteOnceOnly

	// SetLocked is like Set but the caller must already hold the
	// lock.  SetLocked may release, and later re-acquire, the lock
	// any number of times.  Set may acquire, and later release, the
	// lock any number of times
	SetLocked(interface{}) bool
}

LockingWriteOnceOnly is a WriteOnceOnly whose implementation is protected by a lock.

type Readable 

type Readable interface {
	// Get reads the current value of this variable.  If this variable
	// is not set yet then this call blocks until this variable gets a
	// value.
	Get() interface{}

	// IsSet returns immediately with an indication of whether this
	// variable has been set.
	IsSet() bool
}

Readable represents a variable that is initially not set and later becomes set. Some instances may be set to multiple values in series. A Readable for a variable that can only get one value is commonly known as a "future".

type WriteMultiple 

type WriteMultiple interface {
	Readable
	WriteMultipleOnly
}

WriteMultiple represents a variable that is initially not set and can be set one or more times (unlike a traditional "promise", which can be written only once) and is readable.

type WriteMultipleOnly 

type WriteMultipleOnly interface {
	// Set writes a value into this variable and unblocks every
	// goroutine waiting for this variable to have a value
	Set(interface{})
}

WriteMultipleOnly represents a variable that is initially not set and can be set one or more times (unlike a traditional "promise", which can be written only once).

type WriteOnce 

type WriteOnce interface {
	Readable
	WriteOnceOnly
}

WriteOnce represents a variable that is initially not set and can be set once and is readable. This is the common meaning for "promise".

type WriteOnceOnly 

type WriteOnceOnly interface {
	// Set normally writes a value into this variable, unblocks every
	// goroutine waiting for this variable to have a value, and
	// returns true.  In the unhappy case that this variable is
	// already set, this method returns false without modifying the
	// variable's value.
	Set(interface{}) bool
}

WriteOnceOnly represents a variable that is initially not set and can be set once.

Source Files

interface.go

Directories

PathSynopsis
pkg/util/flowcontrol/fairqueuing/promise/lockingpromise
Version
v0.22.0-beta.0
Published
Jun 22, 2021
Platform
js/wasm
Last checked
7 minutes ago –

Tools for package owners.