NonAuthoritativeEventProducer.cxx

Go to the documentation of this file.

 
#include "openlcb/NonAuthoritativeEventProducer.hxx"
#include "openlcb/EventService.hxx"
 
namespace openlcb
{
 
//
// BitRangeNonauthoritativeEventP::send_query_consumer()
//
void BitRangeNonAuthoritativeEventP::send_query_consumer(unsigned bit,
                                                        WriteHelper *writer,
                                                        BarrierNotifiable *done)
{
    HASSERT(bit < size_);
    uint64_t event = eventBaseOff_ == 0 ? eventBase_ + (bit * 2) :
                                          eventBaseOn_ + bit;
    writer->WriteAsync(node_, Defs::MTI_CONSUMER_IDENTIFY,
                       WriteHelper::global(),
                       eventid_to_buffer(event), done);
}
 
//
// BitRangeNonauthoritativeEventP::handle_event_report()
//
void BitRangeNonAuthoritativeEventP::handle_event_report(
                                                const EventRegistryEntry& entry,
                                                EventReport *event,
                                                BarrierNotifiable *done)
{
    done->notify();
    if (!stateCallback_)
    {
        // there is nobody to notify
        return;
    }
 
    switch (entry.user_arg)
    {
        default:
            // uninteresting event range, should never get here
            HASSERT(0);
        case EVENT_BASE:
            if (event->event >= eventBase_ &&
                event->event < (eventBase_ + (size_ * 2)))
            {
                bool value = (event->event % 2) == (eventBase_ % 2);
                stateCallback_((event->event - eventBase_) / 2, value);
            }
            break;
        case EVENT_BASE_ON:
            if (event->event >= eventBaseOn_ &&
                event->event < (eventBaseOn_ + size_))
            {
                stateCallback_((event->event - eventBaseOn_), true);
            }
            break;
        case EVENT_BASE_OFF:
            if (event->event >= eventBaseOff_ &&
                event->event < (eventBaseOff_ + size_))
            {
                stateCallback_((event->event - eventBaseOff_), false);
            }
            break;
    }
}
 
//
// BitRangeNonauthoritativeEventP::handle_consumer_identified()
//
void BitRangeNonAuthoritativeEventP::handle_consumer_identified(
                                                const EventRegistryEntry& entry,
                                                EventReport *event,
                                                BarrierNotifiable *done)
{
    done->notify();
    if (!stateCallback_)
    {
        // there is nobody to notify
        return;
    }
 
    bool value;
    if (event->state == EventState::VALID)
    {
        value = true;
    }
    else if (event->state == EventState::INVALID)
    {
        value = false;
    }
    else
    {
        return; // nothing to learn from this message.
    }
 
    switch (entry.user_arg)
    {
        default:
            // uninteresting event range, should never get here
            HASSERT(0);
        case EVENT_BASE:
            if (event->event >= eventBase_ &&
                event->event < (eventBase_ + (size_ * 2)))
            {
                if ((event->event % 2) != (eventBase_ % 2))
                {
                    value = !value;
                }
                stateCallback_((event->event - eventBase_) / 2, value);
            }
            break;
        case EVENT_BASE_ON:
            if (event->event >= eventBaseOn_ &&
                event->event < (eventBaseOn_ + size_))
            {
                stateCallback_((event->event - eventBase_), value);
            }
            break;
        case EVENT_BASE_OFF:
            if (event->event >= eventBaseOff_ &&
                event->event < (eventBaseOff_ + size_))
            {
                stateCallback_((event->event - eventBaseOff_), !value);
            }
            break;
    }
}
 
//
// BitRangeNonauthoritativeEventP::handle_identify_producer()
//
void BitRangeNonAuthoritativeEventP::handle_identify_global(
                                                const EventRegistryEntry& entry,
                                                EventReport *event,
                                                BarrierNotifiable *done)
{
    if (event->dst_node && event->dst_node != node_)
    {
        done->notify();
    }
    else
    {
        uint64_t range;
        switch (entry.user_arg)
        {
            default:
                // uninteresting event range, should never get here
                HASSERT(0);
            case EVENT_BASE:
                range = EncodeRange(eventBase_, size_ * 2);
                break;
            case EVENT_BASE_ON:
                range = EncodeRange(eventBaseOn_, size_);
                break;
            case EVENT_BASE_OFF:
                range = EncodeRange(eventBaseOff_, size_);
                break;
        }
        event->event_write_helper<1>()->WriteAsync(node_,
            Defs::MTI_PRODUCER_IDENTIFIED_RANGE, WriteHelper::global(),
            eventid_to_buffer(range), done);
    }
}
 
//
// BitRangeNonauthoritativeEventP::handle_identify_producer()
//
void BitRangeNonAuthoritativeEventP::handle_identify_producer(
                                                const EventRegistryEntry& entry,
                                                EventReport *event,
                                                BarrierNotifiable *done)
{
    bool valid = false;
    switch (entry.user_arg)
    {
        default:
            // uninteresting event range, should never get here
            HASSERT(0);
        case EVENT_BASE:
            if (event->event >= eventBase_ &&
                event->event < (eventBase_ + (size_ * 2)))
            {
                valid = true;
            }
            break;
        case EVENT_BASE_ON:
            if (event->event >= eventBaseOn_ &&
                event->event < (eventBaseOn_ + size_))
            {
                valid = true;
            }
            break;
        case EVENT_BASE_OFF:
            if (event->event >= eventBaseOff_ &&
                event->event < (eventBaseOff_ + size_))
            {
                valid = true;
            }
            break;
    }
 
    if (valid)
    {
        event->event_write_helper<1>()->WriteAsync(node_,
            Defs::MTI_PRODUCER_IDENTIFIED_UNKNOWN, WriteHelper::global(),
            eventid_to_buffer(event->event), done);
    }
    else
    {
        done->notify();
    }
}
 
//
// BitRangeNonauthoritativeEventP::set()
//
void BitRangeNonAuthoritativeEventP::set(unsigned bit, bool new_value,
                                         WriteHelper *writer,
                                         BarrierNotifiable *done)
{
    HASSERT(bit < size_);
 
    uint64_t event;
    if (new_value)
    {
        event = eventBaseOff_ == 0 ? eventBase_ + (bit * 2) :
                                     eventBaseOn_ + bit;
    }
    else
    {
        event = eventBaseOff_ == 0 ? eventBase_ + (bit * 2) + 1 :
                                     eventBaseOff_ + bit;
    }
 
    writer->WriteAsync(node_, Defs::MTI_EVENT_REPORT, WriteHelper::global(),
                       eventid_to_buffer(event), done);
}
 
} // namespace openlcb