33 Execution control library [exec]

33.14 Execution scope utilities [exec.scope]

33.14.2 Counting Scopes [exec.counting.scopes]

33.14.2.2 Simple Counting Scope [exec.scope.simple.counting]

33.14.2.2.1 General [exec.scope.simple.counting.general]

33.14.2.2.2 Constructor and Destructor [exec.simple.counting.ctor]

33.14.2.2.3 Members [exec.simple.counting.mem]

33.14.2.2.4 Token [exec.simple.counting.token]

33.14.2.2.1 General [exec.scope.simple.counting.general]

🔗
namespace std::execution { class simple_counting_scope { public: // [exec.simple.counting.token], token struct token; using assoc-t = association-t<simple_counting_scope>; // exposition only static constexpr size_t max_associations = implementation-defined; // [exec.simple.counting.ctor], constructor and destructor simple_counting_scope() noexcept; simple_counting_scope(simple_counting_scope&&) = delete; ~simple_counting_scope(); // [exec.simple.counting.mem], members token get_token() noexcept; void close() noexcept; sender auto join() noexcept; private: size_t count; // exposition only scope-state-type state; // exposition only assoc-t try-associate() noexcept; // exposition only void disassociate() noexcept; // exposition only template<class State> bool start-join-sender(State& state) noexcept; // exposition only }; }
1
#
For purposes of determining the existence of a data race, get_token, close, join, try-associate, disassociate, and start-join-sender behave as atomic operations ([intro.multithread]).
These operations on a single object of type simple_counting_scope appear to occur in a single total order.

33.14.2.2.2 Constructor and Destructor [exec.simple.counting.ctor]

🔗
simple_counting_scope() noexcept;
1
#
Postconditions: count is 0 and state is unused.
🔗
~simple_counting_scope();
2
#
Effects: If state is not one of joined, unused, or unused-and-closed, invokes terminate ([except.terminate]).
Otherwise, has no effects.

33.14.2.2.3 Members [exec.simple.counting.mem]

🔗
token get_token() noexcept;
1
#
Returns: An object t of type simple_counting_scope​::​token such that t.scope == this is true.
🔗
void close() noexcept;
2
#
Effects: If state is
  • (2.1)
    unused, then changes state to unused-and-closed;
  • (2.2)
    open, then changes state to closed;
  • (2.3)
    open-and-joining, then changes state to closed-and-joining;
  • (2.4)
    otherwise, no effects.
3
#
Postconditions: Any subsequent call to try-associate() on *this returns false.
🔗
sender auto join() noexcept;
4
#
Returns: make-sender(scope-join-t(), this).
🔗
assoc-t try-associate() noexcept;
5
#
Effects: If count is equal to max_associations, then no effects.
Otherwise, if state is
  • (5.1)
    unused, then increments count and changes state to open;
  • (5.2)
    open or open-and-joining, then increments count;
  • (5.3)
    otherwise, no effects.
6
#
Returns: If count was incremented, an object of type assoc-t that is engaged and associated with *this, and assoc-t() otherwise.
🔗
void disassociate() noexcept;
7
#
Preconditions: count is greater than zero.
8
#
Effects: Decrements count.
If count is zero after decrementing and state is open-and-joining or closed-and-joining, changes state to joined and calls complete() on all objects registered with *this.
[Note 1: 
Calling complete() on any registered object can cause *this to be destroyed.
— end note]
🔗
template<class State> bool start-join-sender(State& st) noexcept;
9
#
Effects: If state is
  • (9.1)
    unused, unused-and-closed, or joined, then changes state to joined and returns true;
  • (9.2)
    open or open-and-joining, then changes state to open-and-joining, registers st with *this and returns false;
  • (9.3)
    closed or closed-and-joining, then changes state to closed-and-joining, registers st with *this and returns false.

33.14.2.2.4 Token [exec.simple.counting.token]

🔗
namespace std::execution { struct simple_counting_scope::token { template<sender Sender> Sender&& wrap(Sender&& snd) const noexcept; assoc-t try_associate() const noexcept; private: simple_counting_scope* scope; // exposition only }; }
🔗
template<sender Sender> Sender&& wrap(Sender&& snd) const noexcept;
1
#
Returns: std​::​forward<Sender>(snd).
🔗
assoc-t try_associate() const noexcept;
2
#
Effects: Equivalent to: return scope->try-associate();