Class PollNeededCallbackSlot

src/fl/channels/driver.h:84–148

    /// so an ISR cannot observe a function from one registration and a context
    /// from another.
    class PollNeededCallbackSlot {
      private:
        struct Snapshot {
            explicit Snapshot(PollNeededCallback cb) FL_NOEXCEPT
                : callback(cb), next(nullptr) {}

            PollNeededCallback callback;
            Snapshot* next;
        };

      public:
        PollNeededCallbackSlot() FL_NOEXCEPT
            : mSnapshot(nullptr), mRetired(nullptr) {}

        ~PollNeededCallbackSlot() FL_NOEXCEPT {
            Snapshot* active =
                mSnapshot.exchange(nullptr, fl::memory_order_acq_rel);
            destroySnapshots(active);
            destroySnapshots(mRetired);
            mRetired = nullptr;
        }

        void set(PollNeededCallback callback) FL_NOEXCEPT {
            if (callback.callback == nullptr) {
                clear();
                return;
            }
            Snapshot* snapshot = new Snapshot(callback); // ok bare allocation
            retire(mSnapshot.exchange(snapshot, fl::memory_order_acq_rel));
        }

        void clear() FL_NOEXCEPT {
            retire(mSnapshot.exchange(nullptr, fl::memory_order_acq_rel));
        }

        void invoke() const FL_NOEXCEPT {
            Snapshot* snapshot = mSnapshot.load(fl::memory_order_acquire);
            if (snapshot == nullptr) {
                return;
            }
            snapshot->callback.invoke();
        }

      private:
        void retire(Snapshot* snapshot) FL_NOEXCEPT {
            if (snapshot == nullptr) {
                return;
            }
            // An ISR may already have loaded this pointer, so reclaim only when
            // the slot is destroyed and driver teardown has quiesced callbacks.
            snapshot->next = mRetired;
            mRetired = snapshot;
        }

        static void destroySnapshots(Snapshot* snapshot) FL_NOEXCEPT {
            while (snapshot != nullptr) {
                Snapshot* next = snapshot->next;
                delete snapshot; // ok bare allocation