RoutingLogic.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_ROUTNGLOGIC_HXX_
#define _OPENLCB_ROUTNGLOGIC_HXX_
 
#include <set>
#include <map>
#include <unordered_map>
 
#include "os/OS.hxx"
#include "openlcb/EventHandler.hxx"
 
namespace openlcb
{
 
uint8_t event_range_to_bit_count(EventId *event);
 
template <class Port, typename Address> class RoutingLogic
{
public:
    RoutingLogic()
    {
    }
    ~RoutingLogic()
    {
    }
 
    void remove_port(Port *port)
    {
        OSMutexLock l(&lock_);
        eventRoutingTable_.erase(port);
        // Removing entries from a hashmap invalidates an iterator, thus it is
        // safer to null them out than actually remove. Having a null value
        // will cause address lookup to return null for a node that has not
        // been seen since then elsewhere, which is exactly the behavior we
        // want.
        for (auto &it : addressRoutingTable_)
        {
            if (it.second == port)
            {
                it.second = nullptr;
            }
        }
    }
 
    void add_node_id_to_route(Port *port, Address source)
    {
        OSMutexLock l(&lock_);
        addressRoutingTable_[source] = port;
    }
 
    Port *lookup_port_for_address(Address dest)
    {
        OSMutexLock l(&lock_);
        auto it = addressRoutingTable_.find(dest);
        if (it == addressRoutingTable_.end())
            return nullptr;
        return it->second;
    }
 
    void register_consumer(Port *port, EventId event)
    {
        OSMutexLock l(&lock_);
        eventRoutingTable_[port].registeredConsumers_[0].insert(event);
    }
 
    void register_consumer_range(Port *port, EventId encoded_range)
    {
        OSMutexLock l(&lock_);
        uint8_t bit_count = event_range_to_bit_count(&encoded_range);
        eventRoutingTable_[port].registeredConsumers_[bit_count].insert(
            encoded_range);
    }
 
    void register_producer(Port *port, EventId event)
    {
        // For the moment we do not keep separate routing tables for producers
        // and consumers.
        register_consumer(port, event);
    }
 
    void register_producer_range(Port *port, EventId encoded_range)
    {
        // For the moment we do not keep separate routing tables for producers
        // and consumers.
        register_consumer_range(port, encoded_range);
    }
 
    bool check_pcer(Port *port, EventId event)
    {
        OSMutexLock l(&lock_);
        auto ip = eventRoutingTable_.find(port);
        if (ip == eventRoutingTable_.end())
        {
            return false;
        }
        for (auto im = ip->second.registeredConsumers_.begin();
             im != ip->second.registeredConsumers_.end(); ++im)
        {
            if (im->first == 0)
            {
                if (im->second.find(event) != im->second.end())
                    return true;
            }
            else if (im->first == 64)
            {
                if (!im->second.empty())
                    return true;
            }
            else
            {
                EventId masked_range =
                    event & ~((UINT64_C(1) << im->first) - 1);
                if (im->second.find(masked_range) != im->second.end())
                    return true;
            }
        }
        return false;
    }
 
private:
    OSMutex lock_;
 
    std::unordered_map<Address, Port *> addressRoutingTable_;
 
    struct EventSet
    {
        std::map<uint8_t, std::set<EventId>> registeredConsumers_;
    };
 
    std::map<Port *, EventSet> eventRoutingTable_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_ROUTNGLOGIC_HXX_