Hub.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_HUB_HXX_
#define _UTILS_HUB_HXX_
 
#include <stdint.h>
#include <string>
 
#include "executor/Dispatcher.hxx"
#include "can_frame.h"
 
class PipeBuffer;
class PipeMember;
 
template<class S> class StructContainer : public S {
public:
    S& value() {
        return *this;
    }
 
    const void* data() const {
        return &value();
    }
 
    void* data() {
        return &value();
    }
 
    size_t size() {
        return sizeof(S);
    }
};
 
struct CanFrameContainer : public StructContainer<can_frame>
{
    /* Constructor. Sets up (outgoing) frames to be empty extended frames by
     * default. */
    CanFrameContainer()
    {
        can_id = 0;
        CLR_CAN_FRAME_ERR(*this);
        CLR_CAN_FRAME_RTR(*this);
        SET_CAN_FRAME_EFF(*this);
        can_dlc = 0;
    }
 
    struct can_frame *mutable_frame()
    {
        return this;
    }
    const struct can_frame &frame() const
    {
        return *this;
    }
};
 
template <class T> class HubContainer : public T
{
public:
    // typedef FlowInterface<Buffer<HubContainer<T>>> HubMember;
    HubContainer() : skipMember_(0)
    {
    }
    typedef uintptr_t id_type;
    FlowInterface<Buffer<HubContainer<T>>> *skipMember_;
    id_type id()
    {
        return reinterpret_cast<uintptr_t>(skipMember_);
    }
};
 
typedef HubContainer<string> HubData;
 
typedef HubContainer<CanFrameContainer> CanHubData;
 
typedef FlowInterface<Buffer<HubData>> HubPortInterface;
typedef StateFlow<Buffer<HubData>, QList<1>> HubPort;
typedef FlowInterface<Buffer<CanHubData>> CanHubPortInterface;
typedef StateFlow<Buffer<CanHubData>, QList<1>> CanHubPort;
 
static const uintptr_t POINTER_MASK = UINTPTR_MAX;
 
template<class D> class GenericHubFlow : public DispatchFlow<Buffer<D>, 1>
{
public:
    typedef D value_type;
    typedef Buffer<value_type> buffer_type;
    typedef FlowInterface<buffer_type> port_type;
 
    GenericHubFlow(Service *s) : DispatchFlow<Buffer<D>, 1>(s)
    {
        this->negateMatch_ = true;
    }
 
    void register_port(port_type *port)
    {
        this->register_handler(port, reinterpret_cast<uintptr_t>(port),
                               POINTER_MASK);
    }
 
    void unregister_port(port_type *port)
    {
        this->unregister_handler(port, reinterpret_cast<uintptr_t>(port),
                                 POINTER_MASK);
    }
};
 
typedef GenericHubFlow<HubData> HubFlow;
typedef GenericHubFlow<CanHubData> CanHubFlow;
 
class DisplayPort : public HubPort
{
public:
    DisplayPort(Service *service, bool timestamped)
        : HubPort(service)
        , timestamped_(timestamped)
    {
    }
 
    Action entry() override
    {
        string s(message()->data()->data(), message()->data()->size());
        if (timestamped_) {
            long long ts = os_get_time_monotonic();
            printf("%lld.%06lld: %s", ts / 1000000000, (ts / 1000) % 1000000,
                   s.c_str());
        } else {
            printf("%s", s.c_str());
        }
        return release_and_exit();
    }
 
private:
    bool timestamped_; 
};
 
 
class FdHubPortInterface : public Destructable {
public:
    int fd()
    {
        return fd_;
    }
 
protected:
    FdHubPortInterface() : fd_(-1) {}
 
    FdHubPortInterface(int fd) : fd_(fd) {}
 
    int fd_{-1};
};
 
namespace openlcb
{
class FdToTcpParser;
}
 
class FdHubPortService : public FdHubPortInterface, public Service
{
public:
    virtual void report_write_error() = 0;
 
    virtual void report_read_error() = 0;
 
protected:
    // For barrier_.
    template <class HFlow> friend class HubDeviceSelectReadFlow;
    friend class openlcb::FdToTcpParser;
 
    FdHubPortService(ExecutorBase *exec, int fd)
        : FdHubPortInterface(fd)
        , Service(exec)
    {
    }
 
    BarrierNotifiable barrier_;
};
 
#endif // _UTILS_HUB_HXX_