std::stop_t...op_requested(3)

💅 std::stop_t...op_requested(3) 💅

Okay so this is the std::stop_token::stop_requested page from the C++ Standard Libary manual, bestie ✨ (yes, that's the spelling in the source, we are not fixing it 💀). She's giving C++ Standard Library realness, and we're gonna walk through it together 🫶

🌸 NAME 🌸

std::stop_token::stop_requested - std::stop_token::stop_requested

✨ Synopsis ✨

[[nodiscard]] bool stop_requested() const noexcept;  (since C++20)

Checks if the stop_token object has associated stop-state and that state has received a stop request. A default constructed stop_token has no associated stop-state, and thus has not had stop requested.

🫶 Parameters 🫶

(none) — zero parameters, she said "no thoughts, just vibes" 💅

🔥 Return value 🔥

true if the stop_token object has associated stop-state and it received a stop request, false otherwise.

🎀 Example 🎀

       // Run this code

        #include <chrono>
        #include <condition_variable>
        #include <iostream>
        #include <mutex>
        #include <string_view>
        #include <thread>
        using namespace std::chrono_literals;

        int main()
        {
            std::cout << std::boolalpha;
            auto print = [](std::string_view name, const std::stop_token&
       token)
            {
                std::cout << name << ": stop_possible = " <<
       token.stop_possible();
                std::cout << ", stop_requested = " << token.stop_requested() <<
       '\n';
            };

            // A worker thread that will listen to stop requests
            auto stop_worker = std::jthread([](std::stop_token stoken)
            {
                for (int i = 10; i; --i)
                {
                    std::this_thread::sleep_for(300ms);
                    if (stoken.stop_requested())
                    {
                        std::cout << "  Sleepy worker is requested to stop\n";
                        return;
                    }
                    std::cout << "  Sleepy worker goes back to sleep\n";
                }
            });

            // A worker thread that will only stop when completed
            auto inf_worker = std::jthread([]()
            {
                for (int i = 5; i; --i)
                {
                    std::this_thread::sleep_for(300ms);
                    std::cout << "  Run as long as we want\n";
                }
            });

            std::stop_token def_token;
            std::stop_token stop_token = stop_worker.get_stop_token();
            std::stop_token inf_token = inf_worker.get_stop_token();
            print("def_token ", def_token);
            print("stop_token", stop_token);
            print("inf_token ", inf_token);

            std::cout << "\nRequest and join stop_worker:\n";
            stop_worker.request_stop();
            stop_worker.join();

            std::cout << "\nRequest and join inf_worker:\n";
            inf_worker.request_stop();
            inf_worker.join();
            std::cout << '\n';

            print("def_token ", def_token);
            print("stop_token", stop_token);
            print("inf_token ", inf_token);
        }

Possible output:

        def_token : stop_possible = false, stop_requested = false
        stop_token: stop_possible = true, stop_requested = false
        inf_token : stop_possible = true, stop_requested = false

        Request and join stop_worker:
          Run as long as we want
          Sleepy worker is requested to stop

        Request and join inf_worker:
          Run as long as we want
          Run as long as we want
          Run as long as we want
          Run as long as we want

        def_token : stop_possible = false, stop_requested = false
        stop_token: stop_possible = true, stop_requested = true
        inf_token : stop_possible = true, stop_requested = true

That's the whole page, bestie 🫶 Source/version: http://cppreference.com ✨ Date: 2024.06.10 💖 And the footer title was std::stop_t...op_requested(3) — slay, periodt 👑