timer_processor.h

Go to the documentation of this file.

// Copyright (c) 2018, Smart Projects Holdings Ltd
// All rights reserved.
// See LICENSE file for license details.

#ifndef _UGCS_VSM_TIMER_PROCESSOR_H_
#define _UGCS_VSM_TIMER_PROCESSOR_H_

#include <ugcs/vsm/request_context.h>
#include <ugcs/vsm/singleton.h>
#include <thread>
#include <map>

namespace ugcs {
namespace vsm {

class Timer_processor: public Request_processor {
    DEFINE_COMMON_CLASS(Timer_processor, Request_container)

public:
    template <typename... Args>
    static Ptr
    Get_instance(Args &&... args)
    {
        return singleton.Get_instance(std::forward<Args>(args)...);
    }

    Timer_processor();

    typedef Callback_proxy<bool> Handler;

    class Timer: public std::enable_shared_from_this<Timer> {
        DEFINE_COMMON_CLASS(Timer, Timer)

    public:
        Timer(const Timer_processor::Ptr &processor,
              std::chrono::milliseconds interval);

        void
        Cancel();

        bool
        Is_running() const;

        std::chrono::steady_clock::time_point
        Get_fire_time() const
        {
            return fire_time;
        }

    private:
        friend class Timer_processor;

        Timer_processor::Ptr processor;
        bool is_running = true;
        std::chrono::milliseconds interval;
        std::chrono::steady_clock::time_point fire_time;
        Request::Ptr request;
        mutable std::mutex mutex;
        std::list<Ptr> attached_timers;

        void
        Set_request(Request::Ptr &request);

        void
        Fire();

        void
        Destroy(bool cancel = false);

        void
        Attach(Timer::Ptr &timer);

        void
        Attach(std::list<Ptr> &&timers);

        void
        Detach(Timer::Ptr &timer);

        Ptr
        Get_attached();
    };

    Timer::Ptr
    Create_timer(std::chrono::milliseconds interval, const Handler &handler,
                 Request_container::Ptr container);

    void
    Cancel_timer(Timer::Ptr timer);

private:
    typedef decltype(std::chrono::milliseconds().count()) Tick_type;

    std::thread thread;
    std::map<Tick_type, Timer::Ptr> tree;
    std::mutex tree_lock;
    static Singleton<Timer_processor> singleton;

    virtual void
    On_enable() override;

    virtual void
    On_disable() override;

    virtual void
    On_wait_and_process() override;

    void
    Timer_process_handler(Timer::Ptr timer);

    void
    Timer_handler(Timer::Ptr timer, Handler handler,
                  Request_container::Ptr container);

    void
    Insert_timer(Timer::Ptr &timer);

    static Tick_type
    Get_ticks(const std::chrono::steady_clock::time_point &time);

    void
    Create_request(Timer::Ptr &timer, const Handler &handler,
                   Request_container::Ptr &container);
};

} /* namespace vsm */
} /* namespace ugcs */

#endif /* _UGCS_VSM_TIMER_PROCESSOR_H_ */