Represents a one-time asynchronous producer with result setting capability. More...
#include <async.h>
Public Member Functions | |
| promise (const promise &)=delete | |
| promise & | operator= (const promise &)=delete |
| promise (promise &&other) noexcept | |
| promise & | operator= (promise &&other) noexcept |
| promise ()=default | |
| Default constructor creates an invalid promise. | |
| promise (Callback &&c) | |
| Constructs a promise with a computation callback. | |
| future< TYPE > | getFuture () |
| Gets the future associated with this promise. | |
| bool | valid () const noexcept |
| Checks if the promise is still valid (can be executed or have function extracted) | |
| std::function< TYPE()> | function () |
| Extracts the computation function from the promise. | |
| void | run () |
| Executes the computation and sets the result in the associated future. | |
Detailed Description
Represents a one-time asynchronous producer with result setting capability.
- Template Parameters
-
TYPE The result type of the computation Callback The type of the computation callback
Provides the means to set the result of an asynchronous computation. A promise is a single-use object that can be either executed via run() or have its computation function extracted via function(). Once used, the promise becomes invalid and cannot be reused.
Key characteristics:
- Single-use: can be executed or have its function extracted only once
- Thread-safe: internal state is properly synchronized
- Exception-safe: exceptions during computation are properly captured and stored
Constructor & Destructor Documentation
◆ promise() [1/2]
|
default |
Default constructor creates an invalid promise.
Creates a promise that is not associated with any computation. The resulting promise is invalid and cannot be used until assigned a valid promise.
◆ promise() [2/2]
|
explicit |
Constructs a promise with a computation callback.
- Parameters
-
c Callback that will produce the result when executed
The promise takes ownership of the callback and becomes valid. The callback will be invoked exactly once - either by run() or through function().
Member Function Documentation
◆ function()
| std::function< TYPE()> original::async::promise< TYPE, Callback >::function | ( | ) |
Extracts the computation function from the promise.
- Returns
- The computation function that was associated with this promise
- Exceptions
-
sysError if the promise is invalid (already used or default-constructed)
After calling this method:
- The promise becomes invalid
- The caller takes ownership of the computation function
- The promise can no longer be used for execution
- Note
- This is an alternative to run() for manual execution control
◆ getFuture()
| original::async::future< TYPE > original::async::promise< TYPE, Callback >::getFuture | ( | ) |
Gets the future associated with this promise.
- Returns
- A future that will receive the result
- Exceptions
-
Nothing - can be called multiple times while the promise is valid
- Note
- The promise remains valid after calling getFuture()
◆ run()
| void original::async::promise< TYPE, Callback >::run | ( | ) |
Executes the computation and sets the result in the associated future.
- Exceptions
-
sysError if the promise is invalid (already used or default-constructed) Any exception thrown by the computation function (captured in the future)
After calling this method:
- The promise becomes invalid
- The computation result (or exception) is stored in the associated future
- Any waiting futures will be notified of completion
◆ valid()
|
noexcept |
Checks if the promise is still valid (can be executed or have function extracted)
- Returns
- True if the promise holds a valid computation that hasn't been used yet
A promise becomes invalid after:
- run() is called (executes the computation)
- function() is called (extracts the computation function)
- Being default-constructed (no computation associated)
The documentation for this class was generated from the following file:
- src/vibrant/async.h
