EventIdentifyGlobal.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_EVENTIDENTIFYGLOBAL_HXX_
#define _OPENLCB_EVENTIDENTIFYGLOBAL_HXX_
 
#include "openlcb/If.hxx"
#include "utils/Atomic.hxx"
 
namespace openlcb
{
 
class EventIdentifyGlobal : public StateFlowBase, private Atomic
{
public:
    EventIdentifyGlobal(Node *node)
        : StateFlowBase(node->iface())
        , eventIdentifyGlobalHandler_(
              this, &EventIdentifyGlobal::handle_incoming_event_identify_global)
        , timer_(this)
        , node_(node)
        , aborted_(false)
        , deleteSelf_(false)
    {
        node_->iface()->dispatcher()->register_handler(
            &eventIdentifyGlobalHandler_, Defs::MTI_EVENTS_IDENTIFY_GLOBAL,
            Defs::MTI_EXACT);
    }
 
    ~EventIdentifyGlobal()
    {
        node_->iface()->dispatcher()->unregister_handler(
            &eventIdentifyGlobalHandler_, Defs::MTI_EVENTS_IDENTIFY_GLOBAL,
            Defs::MTI_EXACT);
    }
 
    void arm(bool delete_self = false)
    {
        AtomicHolder h(this);
        if (is_terminated())
        {
            aborted_ = false;
            deleteSelf_ = delete_self;
            start_flow(STATE(entry));
        }
    }
 
private:
    void handle_incoming_event_identify_global(Buffer<GenMessage> *msg)
    {
        msg->unref();
        AtomicHolder h(this);
        aborted_ = true;
    }
 
    Action entry()
    {
        // get a pseudo random number between 1.500 and 2.011 seconds
        uint64_t h = node_->node_id() * 0x1c19a66d;
        uint32_t hh = h ^ (h >> 32);
        hh = hh ^ (hh >> 12) ^ (hh >> 24);
        long long timeout_msec = 1500 + (hh & 0x1FF);
 
        return sleep_and_call(
            &timer_, MSEC_TO_NSEC(timeout_msec), STATE(timeout));
    }
 
    Action timeout()
    {
        {
            // Making the state flow termination atomic cleans up a potential
            // race condition with an arm() call coming in after the if
            // statement but before the StateFlowBase::exit() call.
            AtomicHolder h(this);
            if (aborted_)
            {
                // no need to send Event Identify Global, already detected one
                return deleteSelf_ ? delete_this() : exit();
            }
        }
 
        if (!node_->is_initialized())
        {
            // node not initialized yet, try again later
            return call_immediately(STATE(entry));
        }
 
        // allocate a buffer for the Event Identify Global message
        return allocate_and_call(
            node_->iface()->global_message_write_flow(), STATE(fill_buffer));
    }
 
    Action fill_buffer()
    {
        auto *b = get_allocation_result(
            node_->iface()->global_message_write_flow());
        b->data()->reset(
            Defs::MTI_EVENTS_IDENTIFY_GLOBAL, node_->node_id(), EMPTY_PAYLOAD);
        node_->iface()->global_message_write_flow()->send(b);
 
        return deleteSelf_ ? delete_this() : exit();
    }
 
    MessageHandler::GenericHandler eventIdentifyGlobalHandler_;
    StateFlowTimer timer_; 
    Node *node_; 
    uint8_t aborted_ : 1; 
    uint8_t deleteSelf_ : 1; 
};
 
} // namespace openlcb
 
#endif // _OPENLCB_EVENTIDENTIFYGLOBAL_HXX_