dispatcher.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
 */
 
#ifndef UAVCAN_TRANSPORT_DISPATCHER_HPP_INCLUDED
#define UAVCAN_TRANSPORT_DISPATCHER_HPP_INCLUDED
 
#include <cassert>
#include <uavcan/error.hpp>
#include <uavcan/std.hpp>
#include <uavcan/build_config.hpp>
#include <uavcan/transport/perf_counter.hpp>
#include <uavcan/transport/transfer_listener.hpp>
#include <uavcan/transport/outgoing_transfer_registry.hpp>
#include <uavcan/transport/can_io.hpp>
#include <uavcan/util/linked_list.hpp>
 
namespace uavcan
{
 
class UAVCAN_EXPORT Dispatcher;
 
#if !UAVCAN_TINY
 
class UAVCAN_EXPORT LoopbackFrameListenerBase : public LinkedListNode<LoopbackFrameListenerBase>
{
    Dispatcher& dispatcher_;
 
protected:
    explicit LoopbackFrameListenerBase(Dispatcher& dispatcher)
        : dispatcher_(dispatcher)
    { }
 
    virtual ~LoopbackFrameListenerBase() { stopListening(); }
 
    void startListening();
    void stopListening();
    bool isListening() const;
 
    Dispatcher& getDispatcher() { return dispatcher_; }
 
public:
    virtual void handleLoopbackFrame(const RxFrame& frame) = 0;
};
 
 
class UAVCAN_EXPORT LoopbackFrameListenerRegistry : Noncopyable
{
    LinkedListRoot<LoopbackFrameListenerBase> listeners_;
 
public:
    void add(LoopbackFrameListenerBase* listener);
    void remove(LoopbackFrameListenerBase* listener);
    bool doesExist(const LoopbackFrameListenerBase* listener) const;
    unsigned getNumListeners() const { return listeners_.getLength(); }
 
    void invokeListeners(RxFrame& frame);
};
 
class UAVCAN_EXPORT IRxFrameListener
{
public:
    virtual ~IRxFrameListener() { }
 
    virtual void handleRxFrame(const CanRxFrame& frame, CanIOFlags flags) = 0;
};
#endif
 
class UAVCAN_EXPORT Dispatcher : Noncopyable
{
    CanIOManager canio_;
    ISystemClock& sysclock_;
    OutgoingTransferRegistry outgoing_transfer_reg_;
    TransferPerfCounter perf_;
 
    class ListenerRegistry
    {
        LinkedListRoot<TransferListener> list_;
 
        class DataTypeIDInsertionComparator
        {
            const DataTypeID id_;
        public:
            explicit DataTypeIDInsertionComparator(DataTypeID id) : id_(id) { }
            bool operator()(const TransferListener* listener) const
            {
                UAVCAN_ASSERT(listener);
                return id_ > listener->getDataTypeDescriptor().getID();
            }
        };
 
    public:
        enum Mode { UniqueListener, ManyListeners };
 
        bool add(TransferListener* listener, Mode mode);
        void remove(TransferListener* listener);
        bool exists(DataTypeID dtid) const;
        void cleanup(MonotonicTime ts);
        void handleFrame(const RxFrame& frame);
 
        unsigned getNumEntries() const { return list_.getLength(); }
 
        const LinkedListRoot<TransferListener>& getList() const { return list_; }
    };
 
    ListenerRegistry lmsg_;
    ListenerRegistry lsrv_req_;
    ListenerRegistry lsrv_resp_;
 
#if !UAVCAN_TINY
    LoopbackFrameListenerRegistry loopback_listeners_;
    IRxFrameListener* rx_listener_;
#endif
 
    NodeID self_node_id_;
    bool self_node_id_is_set_;
 
    void handleFrame(const CanRxFrame& can_frame);
 
    void handleLoopbackFrame(const CanRxFrame& can_frame);
 
    void notifyRxFrameListener(const CanRxFrame& can_frame, CanIOFlags flags);
 
public:
    Dispatcher(ICanDriver& driver, IPoolAllocator& allocator, ISystemClock& sysclock)
        : canio_(driver, allocator, sysclock)
        , sysclock_(sysclock)
        , outgoing_transfer_reg_(allocator)
#if !UAVCAN_TINY
        , rx_listener_(UAVCAN_NULLPTR)
#endif
        , self_node_id_(NodeID::Broadcast)  // Default
        , self_node_id_is_set_(false)
    { }
 
    int spin(MonotonicTime deadline);
 
    int spinOnce();
 
    int send(const Frame& frame, MonotonicTime tx_deadline, MonotonicTime blocking_deadline,
             CanIOFlags flags, uint8_t iface_mask);
 
    void cleanup(MonotonicTime ts);
 
    bool registerMessageListener(TransferListener* listener);
    bool registerServiceRequestListener(TransferListener* listener);
    bool registerServiceResponseListener(TransferListener* listener);
 
    void unregisterMessageListener(TransferListener* listener);
    void unregisterServiceRequestListener(TransferListener* listener);
    void unregisterServiceResponseListener(TransferListener* listener);
 
    bool hasSubscriber(DataTypeID dtid) const;
    bool hasPublisher(DataTypeID dtid) const;
    bool hasServer(DataTypeID dtid) const;
 
    unsigned getNumMessageListeners()         const { return lmsg_.getNumEntries(); }
    unsigned getNumServiceRequestListeners()  const { return lsrv_req_.getNumEntries(); }
    unsigned getNumServiceResponseListeners() const { return lsrv_resp_.getNumEntries(); }
 
    const LinkedListRoot<TransferListener>& getListOfMessageListeners() const
    {
        return lmsg_.getList();
    }
    const LinkedListRoot<TransferListener>& getListOfServiceRequestListeners() const
    {
        return lsrv_req_.getList();
    }
    const LinkedListRoot<TransferListener>& getListOfServiceResponseListeners() const
    {
        return lsrv_resp_.getList();
    }
    OutgoingTransferRegistry& getOutgoingTransferRegistry() { return outgoing_transfer_reg_; }
 
#if !UAVCAN_TINY
    LoopbackFrameListenerRegistry& getLoopbackFrameListenerRegistry() { return loopback_listeners_; }
 
    IRxFrameListener* getRxFrameListener() const { return rx_listener_; }
    void removeRxFrameListener() { rx_listener_ = UAVCAN_NULLPTR; }
    void installRxFrameListener(IRxFrameListener* listener)
    {
        UAVCAN_ASSERT(listener != UAVCAN_NULLPTR);
        rx_listener_ = listener;
    }
#endif
 
    NodeID getNodeID() const { return self_node_id_; }
    bool setNodeID(NodeID nid);
 
    bool isPassiveMode() const { return !getNodeID().isUnicast(); }
 
    const ISystemClock& getSystemClock() const { return sysclock_; }
    ISystemClock& getSystemClock() { return sysclock_; }
 
    const CanIOManager& getCanIOManager() const { return canio_; }
    CanIOManager& getCanIOManager() { return canio_; }
 
    const TransferPerfCounter& getTransferPerfCounter() const { return perf_; }
    TransferPerfCounter& getTransferPerfCounter() { return perf_; }
};
 
}
 
#endif // UAVCAN_TRANSPORT_DISPATCHER_HPP_INCLUDED