StateChangeDistributor.hh

Go to the documentation of this file.

#ifndef STATECHANGEDISTRIBUTOR_HH
#define STATECHANGEDISTRIBUTOR_HH
 
#include "EmuTime.hh"
#include "ReverseManager.hh"
#include "StateChangeListener.hh"
 
#include "ScopedAssign.hh"
 
#include <vector>
 
namespace openmsx {
 
class StateChangeDistributor
{
public:
        StateChangeDistributor() = default;
        StateChangeDistributor(const StateChangeDistributor&) = delete;
        StateChangeDistributor(StateChangeDistributor&&) = delete;
        StateChangeDistributor& operator=(const StateChangeDistributor&) = delete;
        StateChangeDistributor& operator=(StateChangeDistributor&&) = delete;
        ~StateChangeDistributor();
 
        void registerListener  (StateChangeListener& listener);
        void unregisterListener(StateChangeListener& listener);
 
        void registerRecorder  (ReverseManager& recorder);
        void unregisterRecorder(ReverseManager& recorder);
 
        template<typename T, typename... Args>
        void distributeNew(EmuTime::param time, Args&& ...args) {
                if (recorder) {
                        if (isReplaying()) {
                                if (viewOnlyMode || blockNewEventsDuringReplay) return;
                                stopReplay(time);
                        }
                        assert(!isReplaying());
                        const auto& event = recorder->record<T>(time, std::forward<Args>(args)...);
                        distribute(event); // might throw, ok
                } else {
                        T event(time, std::forward<Args>(args)...);
                        distribute(event); // might throw, ok
                }
        }
 
        void distributeReplay(const StateChange& event) const {
                assert(isReplaying());
                distribute(event);
        }
 
        void stopReplay(EmuTime::param time);
 
        void setViewOnlyMode(bool value) { viewOnlyMode = value; }
        [[nodiscard]] bool isViewOnlyMode() const { return viewOnlyMode; }
 
        [[nodiscard]] auto tempBlockNewEventsDuringReplay() {
                return ScopedAssign{blockNewEventsDuringReplay, true};
        }
 
        [[nodiscard]] bool isReplaying() const;
 
private:
        [[nodiscard]] bool isRegistered(StateChangeListener* listener) const;
        void distribute(const StateChange& event) const;
 
private:
        std::vector<StateChangeListener*> listeners; // unordered
        ReverseManager* recorder = nullptr;
        bool viewOnlyMode = false;
        bool blockNewEventsDuringReplay = false; // used when executing callbacks during replay
};
 
} // namespace openmsx
 
#endif