BroadcastTime.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_BROADCASTTIME_HXX_
#define _OPENLCB_BROADCASTTIME_HXX_
 
#include <functional>
 
#include "openlcb/BroadcastTimeDefs.hxx"
#include "openlcb/EventHandlerTemplates.hxx"
#include "utils/TimeBase.hxx"
 
namespace openlcb
{
 
class BroadcastTime : public SimpleEventHandler
                    , public StateFlowBase
                    , public TimeBase
{
public:
    typedef size_t UpdateSubscribeHandle;
 
    typedef std::function<void(time_t old, time_t current)> TimeUpdateCallback;
 
    virtual ~BroadcastTime()
    {
    }
 
    void set_time(int hours, int minutes)
    {
        EventId event_id = BroadcastTimeDefs::EVENT_SET_SUFFIX_MASK |
            BroadcastTimeDefs::time_to_event(eventBase_, hours, minutes);
        send_event(node_, event_id);
    }
 
    void set_date(int month, int day)
    {
        EventId event_id = BroadcastTimeDefs::EVENT_SET_SUFFIX_MASK |
            BroadcastTimeDefs::date_to_event(eventBase_, month, day);
        send_event(node_, event_id);
    }
 
    void set_year(int year)
    {
        EventId event_id = BroadcastTimeDefs::EVENT_SET_SUFFIX_MASK |
            BroadcastTimeDefs::year_to_event(eventBase_, year);
        send_event(node_, event_id);
    }
 
    void set_date_year_str(const char *date_year);
 
    void set_rate_quarters(int16_t rate)
    {
        EventId event_id = BroadcastTimeDefs::EVENT_SET_SUFFIX_MASK |
            BroadcastTimeDefs::rate_to_event(eventBase_, rate);
        send_event(node_, event_id);
    }
 
    void start()
    {
        send_event(node_, eventBase_ | BroadcastTimeDefs::START_EVENT_SUFFIX);
    }
 
    void stop()
    {
        send_event(node_, eventBase_ | BroadcastTimeDefs::STOP_EVENT_SUFFIX);
    }
 
    void query()
    {
        send_event(node_, eventBase_ | BroadcastTimeDefs::QUERY_EVENT_SUFFIX);
    }
 
    UpdateSubscribeHandle update_subscribe_add(TimeUpdateCallback callback)
    {
        AtomicHolder h(this);
        for (size_t i = 0; i < callbacks_.size(); ++i)
        {
            // atempt to garbage collect unused entries
            if (callbacks_[i] == nullptr)
            {
                callbacks_[i] = std::move(callback);
                return i;
            }
        }
        callbacks_.emplace_back(std::move(callback));
        return callbacks_.size() - 1;
    }
 
    void update_subscribe_remove(UpdateSubscribeHandle handle)
    {
        AtomicHolder h(this);
        callbacks_[handle] = nullptr;
    }
 
    Node *node()
    {
        return node_;
    }
 
    NodeID clock_id()
    {
        return eventBase_ >> 16;
    }
 
    EventId event_base()
    {
        return eventBase_;
    }
 
    const struct tm *gmtime_recalculate()
    {
        gmtime_r(&tm_);
        return &tm_;
    }
 
    const struct tm *gmtime_get()
    {
        return &tm_;
    }
 
    virtual bool is_server_detected() = 0;
 
    virtual bool is_server_self() = 0;
 
protected:
    BroadcastTime(Node *node, NodeID clock_id)
        : StateFlowBase(node->iface())
        , node_(node)
        , eventBase_((uint64_t)clock_id << 16)
        , writer_()
        , timer_(this)
        , callbacks_()
        , rateRequested_(0)
    {
        // use a process-local timezone
        clear_timezone();
 
        time_t time = 0;
        ::gmtime_r(&time, &tm_);
        tm_.tm_isdst = 0;
    }
 
    virtual void set_shortcut(uint64_t event)
    {
    }
 
    void service_callbacks(time_t old, time_t current)
    {
        AtomicHolder h(this);
        for (auto n : callbacks_)
        {
            if (n)
            {
                n(old, current);
            }
        }
    }
 
    struct tm tm_; 
 
    Node *node_; 
    EventId eventBase_; 
    WriteHelper writer_; 
    StateFlowTimer timer_; 
 
    std::vector<TimeUpdateCallback> callbacks_;
 
    int16_t rateRequested_; 
 
private:
    void clear_timezone();
 
    DISALLOW_COPY_AND_ASSIGN(BroadcastTime);
};
 
} // namespace openlcb
 
#endif // _OPENLCB_BROADCASTTIME_HXX_