mostlyharmless_DatabasePropertyWatcher.h

Go to the documentation of this file.

//
// Created by Syl Morrison on 13/04/2025.
//
 
#ifndef MOSTLYHARMLESS_DATABASEPROPERTYWATCHER_H
#define MOSTLYHARMLESS_DATABASEPROPERTYWATCHER_H
#include <mostly_harmless/data/mostlyharmless_DatabaseState.h>
#include <mostly_harmless/mostlyharmless_Concepts.h>
#include <mostly_harmless/utils/mostlyharmless_Timer.h>
#include <mostly_harmless/utils/mostlyharmless_Proxy.h>
namespace mostly_harmless::data {
    template <DatabaseStorageType T>
    class DatabasePropertyWatcher final {
    private:
        struct Private {};
 
    public:
        DatabasePropertyWatcher(Private, DatabaseState&& databaseState, std::string_view name, int pollFrequencyMs, std::function<void(const T&)>&& callback) : m_databaseState(std::move(databaseState)),
                                                                                                                                                                m_propertyNameToWatch(name),
                                                                                                                                                                m_pollFrequencyMs(pollFrequencyMs),
                                                                                                                                                                m_callback(std::move(callback)) {
            m_proxyThis = utils::Proxy<DatabasePropertyWatcher<T>>::create(this);
            auto proxyCopy = m_proxyThis;
            m_timer.action = [this, proxyCopy]() -> void {
                if (!proxyCopy->isValid()) {
                    return;
                }
                timerCallback();
            };
            m_timer.run(m_pollFrequencyMs);
        }

        DatabasePropertyWatcher(const DatabasePropertyWatcher& /*other*/) = delete;
        DatabasePropertyWatcher(DatabasePropertyWatcher&& /*other*/) noexcept = delete;

        ~DatabasePropertyWatcher() noexcept {
            m_proxyThis->null();
        }

        auto operator=(const DatabasePropertyWatcher& /*other*/) -> DatabasePropertyWatcher = delete;

        auto operator=(DatabasePropertyWatcher&& /*other*/) noexcept -> DatabasePropertyWatcher = delete;

        static auto tryCreate(const DatabaseState& databaseState, std::string_view propertyName, int pollFrequencyMs, std::function<void(const T&)>&& callback) -> std::unique_ptr<DatabasePropertyWatcher> {
            auto databaseCopyOpt = databaseState.duplicate();
            if (!databaseCopyOpt) {
                return nullptr;
            }
            return std::make_unique<DatabasePropertyWatcher<T>>(Private{}, std::move(*databaseCopyOpt), propertyName, pollFrequencyMs, std::move(callback));
        }
 
 
    private:
        auto timerCallback() -> void {
            if (!m_callback) {
                return;
            }
            const auto getRes = m_databaseState.get<T>(m_propertyNameToWatch);
            if (!getRes) {
                assert(false);
                return;
            }
            const auto hasChanged = m_previousValue != getRes;
            m_previousValue = *getRes;
            if (!hasChanged) {
                return;
            }
            m_callback(*getRes);
        }
 
        DatabaseState m_databaseState;
        std::string m_propertyNameToWatch;
        int m_pollFrequencyMs;
        std::function<void(const T&)> m_callback;
        std::shared_ptr<utils::Proxy<DatabasePropertyWatcher<T>>> m_proxyThis;
        utils::Timer m_timer;
        std::optional<T> m_previousValue{};
    };
} // namespace mostly_harmless::data
#endif // MOSTLYHARMLESS_DATABASEPROPERTYWATCHER_H