promise

Documentation

Index

• type LockingReadable
• type LockingWriteMultiple
• type LockingWriteMultipleOnly
• type LockingWriteOnce
• type LockingWriteOnceOnly
• type Readable
• type WriteMultiple
• type WriteMultipleOnly
• type WriteOnce
• type WriteOnceOnly

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.