BroadcastTimeServer.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_BROADCASTTIMESERVER_HXX_
#define _OPENLCB_BROADCASTTIMESERVER_HXX_
 
#include "openlcb/BroadcastTime.hxx"
#include "openlcb/BroadcastTimeAlarm.hxx"
 
namespace openlcb
{
 
class BroadcastTimeServerTime;
class BroadcastTimeServerSync;
class BroadcastTimeServerSet;
class BroadcastTimeServerAlarm;
 
class BroadcastTimeServer : public BroadcastTime
{
public:
    BroadcastTimeServer(Node *node, NodeID clock_id);
 
    ~BroadcastTimeServer();
 
    bool is_server_detected() override
    {
        return true;
    }
 
    bool is_server_self() override
    {
        return true;
    }
 
#if defined(GTEST)
    void shutdown();
 
    bool is_shutdown();
#endif
 
private:
    void handle_identify_global(const EventRegistryEntry &entry,
                                EventReport *event,
                                BarrierNotifiable *done) override
    {
        AutoNotify an(done);
        if (event->dst_node && event->dst_node != node_)
        {
            // not for us
            return;
        }
 
        if (is_terminated())
        {
            start_flow(STATE(query_response));
        }
 
        event->event_write_helper<1>()->WriteAsync(
            node_, Defs::MTI_PRODUCER_IDENTIFIED_RANGE, WriteHelper::global(),
            eventid_to_buffer(EncodeRange(entry.event, 0x1 << 16)),
            done->new_child());
 
        // we can configure ourselves
        event->event_write_helper<2>()->WriteAsync(
            node_, Defs::MTI_CONSUMER_IDENTIFIED_RANGE, WriteHelper::global(),
            eventid_to_buffer(EncodeRange(entry.event + 0x8000, 0x1 << 15)),
            done->new_child());
    }
 
    void handle_identify_consumer(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override
    {
        AutoNotify an(done);
 
        if (event->event >= (eventBase_ + 0x8000))
        {
            // we can configure ourselves
            event->event_write_helper<1>()->WriteAsync(
                node_, Defs::MTI_CONSUMER_IDENTIFIED_RANGE,
                WriteHelper::global(),
                eventid_to_buffer(EncodeRange(entry.event + 0x8000, 0x1 << 15)),
                done->new_child());
        }
    }
 
    void handle_identify_producer(const EventRegistryEntry &entry,
                                  EventReport *event,
                                  BarrierNotifiable *done) override
    {
        AutoNotify an(done);
        event->event_write_helper<1>()->WriteAsync(
            node_, Defs::MTI_PRODUCER_IDENTIFIED_RANGE, WriteHelper::global(),
            eventid_to_buffer(EncodeRange(entry.event, 0x1 << 16)),
            done->new_child());
    }
 
    void handle_consumer_identified(const EventRegistryEntry &entry,
                                    EventReport *event,
                                    BarrierNotifiable *done) override;
 
 
    void handle_consumer_range_identified(
        const EventRegistryEntry &registry_entry, EventReport *event,
        BarrierNotifiable *done) override;
 
    void handle_event_report(const EventRegistryEntry &entry,
                             EventReport *event,
                             BarrierNotifiable *done) override;
 
    virtual void set_shortcut(uint64_t event) override;
 
    Action entry()
    {
        return sleep_and_call(&timer_, MSEC_TO_NSEC(300),
                              STATE(query_response));
    }
 
    Action query_response();
 
    //BroadcastTimeAlarmDate alarmDate_; ///< date rollover alarm
    time_t secondsRequested_; 
    uint16_t updateRequested_ : 1; 
#if defined(GTEST)
    uint16_t shutdown_ : 1;
#endif
 
    BroadcastTimeServerTime *time_;
    BroadcastTimeServerSync *sync_;
    BroadcastTimeServerSet *set_;
    BroadcastTimeServerAlarm *alarm_;
 
    friend class BroadcastTimeServerTime;
    friend class BroadcastTimeServerSync;
    friend class BroadcastTimeServerSet;
    friend class BroadcastTimeServerAlarm;
 
 
    DISALLOW_COPY_AND_ASSIGN(BroadcastTimeServer);
};
 
} // namespace openlcb
 
#endif // _OPENLCB_BROADCASTTIMESERVER_HXX_