CBroker.hpp

Go to the documentation of this file.

#ifndef FREEDM_BROKER_HPP
#define FREEDM_BROKER_HPP

#include "CClockSynchronizer.hpp"

#include <list>
#include <string>

#include <boost/asio.hpp>
#include <boost/asio/deadline_timer.hpp>
#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/thread/shared_mutex.hpp>

namespace freedm {
    namespace broker {

class CConnectionManager;
class CDispatcher;

const unsigned int ALIGNMENT_DURATION = 250;

class CBroker : private boost::noncopyable
{
public:
    typedef boost::function<void (boost::system::error_code)> Scheduleable;
    typedef boost::function<void ()> BoundScheduleable;
    typedef std::string ModuleIdent;
    typedef std::pair<ModuleIdent, boost::posix_time::time_duration> PhaseTuple;
    typedef std::vector< PhaseTuple > ModuleVector;
    typedef unsigned int PhaseMarker;
    typedef unsigned int TimerHandle;
    typedef std::map<TimerHandle, ModuleIdent> TimerAlloc;
    typedef std::map<TimerHandle, boost::asio::deadline_timer* > TimersMap;
    typedef std::map<TimerHandle, bool > NextTimeMap;
    typedef std::map<ModuleIdent, std::list< BoundScheduleable > > ReadyMap;

    static CBroker& Instance();

    ~CBroker();

    void Run();

    boost::asio::io_service& GetIOService();

    void Stop(unsigned int signum = 0);

    void HandleSignal(const boost::system::error_code& error, int parameter);

    void HandleStop(unsigned int signum = 0);

    int Schedule(TimerHandle h, boost::posix_time::time_duration wait, Scheduleable x);

    int Schedule(ModuleIdent m, BoundScheduleable x, bool start_worker=true);

    TimerHandle AllocateTimer(ModuleIdent module);

    void RegisterModule(ModuleIdent m, boost::posix_time::time_duration phase);

    bool IsModuleRegistered(ModuleIdent m);

    boost::posix_time::time_duration TimeRemaining();

    CClockSynchronizer& GetClockSynchronizer();

private:
    CBroker();

    boost::asio::io_service m_ioService;

    void ChangePhase(const boost::system::error_code &err);

    void ScheduledTask(Scheduleable x, TimerHandle handle, const boost::system::error_code &err);

    void Worker();

    bool m_busy;

    boost::posix_time::ptime m_last_alignment;

    ModuleVector m_modules;

    PhaseMarker m_phase;

    boost::posix_time::ptime m_phaseends;

    boost::asio::deadline_timer m_phasetimer;

    TimerHandle m_handlercounter;

    TimerAlloc m_allocs;

    TimersMap m_timers;

    NextTimeMap m_nexttime;

    NextTimeMap m_ntexpired;

    ReadyMap m_ready;

    boost::mutex m_schmutex;

    boost::shared_ptr<CClockSynchronizer> m_synchronizer;

    boost::asio::signal_set m_signals;

    bool m_stopping;

    boost::mutex m_stoppingMutex;
};

    } // namespace broker
} // namespace freedm

#endif // FREEDM_BROKER_HPP