DevicePoller.h

#pragma once

#include <Poco/Clock.h>
#include <Poco/Mutex.h>

#include "core/DeviceCache.h"
#include "core/Distributor.h"
#include "core/PollableDevice.h"
#include "loop/StoppableRunnable.h"
#include "loop/StopControl.h"
#include "util/AsyncExecutor.h"
#include "util/Loggable.h"

namespace BeeeOn {

class DevicePoller : public StoppableRunnable, Loggable {
public:
        typedef Poco::SharedPtr<DevicePoller> Ptr;

        DevicePoller();

        void setDistributor(Distributor::Ptr distributor);
        void setPollExecutor(AsyncExecutor::Ptr executor);

        void setWarnThreshold(const Poco::Timespan &threshold);

        void schedule(
                PollableDevice::Ptr device,
                const Poco::Clock &now = {});

        void cancel(const DeviceID &id);

        void run() override;

        void stop() override;

        void cleanup();

protected:
        static Poco::Timespan grabRefresh(const PollableDevice::Ptr device);

        void reschedule(
                PollableDevice::Ptr device,
                const Poco::Clock &now = {});

        void doSchedule(
                PollableDevice::Ptr device,
                const Poco::Clock &now = {});

        Poco::Timespan pollNextIfOnSchedule(const Poco::Clock &now = {});

        void doPoll(PollableDevice::Ptr device);

private:
        Distributor::Ptr m_distributor;
        AsyncExecutor::Ptr m_pollExecutor;
        Poco::Timespan m_warnThreshold;

        typedef std::multimap<Poco::Clock, PollableDevice::Ptr> Schedule;
        Schedule m_schedule;
        std::map<DeviceID, Schedule::const_iterator> m_devices;
        std::set<DeviceID> m_active;
        Poco::FastMutex m_lock;

        StopControl m_stopControl;
};

}