Class ExampleOwner

test/unit_tests/endpoint_tests/test_timer.cpp:33–72

TEST_F(test_example_use_case, a_const_shared_ptr_of_timer_is_thread_safe) {
    class ExampleOwner : public std::enable_shared_from_this<ExampleOwner> {
        struct hidden { }; // private struct ensures that ::create is used for a proper setup
    public:
        static std::shared_ptr<ExampleOwner> create(boost::asio::io_context& _io) {
            auto p = std::make_shared<ExampleOwner>(hidden{}, _io);
            // 1. ensures that task is properly set before any actual usage of the timer.
            // 2. capture this by weak_ref to avoid the need of manual destruction of the timer.
            // Note: This step can not be done in the c'tor as the weak_from_this/shared_from_this call would return a nullptr at this
            // point.
            // Note: This two step setup is inevitable as the task of the timer and the owner of the timer form an ownership cycle (although
            // only temporary due to the usage of weak_from_this).

            // the return can be ignored in this very instance, because the timer had no chance to have been
            // started before. The return is given, to highlight that adjusting the timers task at a later
            // stage is a dangerous operation and has a chance to fail (because the timer class itself will
            // protect against the change of the task while the timer is running).
            [[maybe_unused]] bool set_was_success = p->timer_->set_task([weak_ref = p->weak_from_this()] {
                if (auto self = weak_ref.lock(); self) {
                    self->counter_ += 1;
                }
                return true;
            });
            return p;
        }

        ExampleOwner([[maybe_unused]] hidden _, boost::asio::io_context& _io) :
            // create a timer with a dummy task to ensure the shared_ptr is receiving its memory in the ctor and can therefore be
            // used from any thread without further inspection
            timer_(timer::create(_io, 12ms, [] { return false; })) { }

        // Because the timer has a thread-safe interface, the shared_ptr to the timer is const, and the task is setup is ensured
        // in a dedicated create function there is no need for synchronization primitives when using the timer itself.
        void start() { timer_->start(); }
        void stop() { timer_->stop(); }

        std::atomic<uint32_t> counter_{0};

    private:
        std::shared_ptr<timer> const timer_;
    };

    auto owner = ExampleOwner::create(dummy_context_);
    // start the timer