TractionTrain.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_TRACTIONTRAIN_HXX_
#define _OPENLCB_TRACTIONTRAIN_HXX_
 
#include <set>
 
#include "executor/Service.hxx"
#include "openlcb/DefaultNodeRegistry.hxx"
#include "openlcb/Node.hxx"
#include "openlcb/TractionDefs.hxx"
#include "openlcb/TrainInterface.hxx"
 
namespace openlcb
{
 
 
class TrainService;
 
class TrainNode : public Node
{
public:
    ~TrainNode();
 
    virtual TrainImpl *train() = 0;
 
    virtual bool function_policy(NodeHandle src, uint8_t command_byte,
        uint32_t fnum, uint16_t value, Notifiable *done) = 0;
 
    virtual void command_hook(NodeHandle src, const Payload& p) = 0;
    
    virtual NodeHandle get_controller() = 0;
 
    virtual void set_controller(NodeHandle id) = 0;
 
    // Thread-safety information
    //
    // The consisting functionality is thread-compatible, which means that it
    // is the responsibility of the caller to ensure that no two threads are
    // calling these methods concurrently.
    //
    // In practice these methods are always called from the TractionService
    // which only operates on a single thread (the service's executor) and will
    // only process one request at a time. All traction protocol requests being
    // forwarded and thus traversing the consist list will be fully processed
    // before any consist change requests would reach the front of the queue
    // for the traction flow.
 
    virtual bool add_consist(NodeID tgt, uint8_t flags) = 0;
 
    virtual bool remove_consist(NodeID tgt) = 0;
    
    virtual NodeID query_consist(int id, uint8_t* flags) = 0;
 
    virtual int query_consist_length() = 0;
};
 
struct ConsistEntry : public QMember
{
    ConsistEntry(NodeID s, uint8_t flags)
        : payload((s << 8) | flags)
    {
    }
    NodeID get_slave() const
    {
        return payload >> 8;
    }
    uint8_t get_flags() const
    {
        return payload & 0xff;
    }
    void set_flags(uint8_t new_flags)
    {
        payload ^= (payload & 0xff);
        payload |= new_flags;
    }
 
private:
    uint64_t payload;
};
 
class TrainNodeWithConsist : public TrainNode {
public:
    ~TrainNodeWithConsist();
 
    bool function_policy(NodeHandle src, uint8_t command_byte, uint32_t fnum,
        uint16_t value, Notifiable *done) override
    {
        AutoNotify an(done);
        return true;
    }
 
    void command_hook(NodeHandle src, const Payload &p) override
    {
    }
 
    bool add_consist(NodeID tgt, uint8_t flags) override
    {
        if (!tgt)
        {
            return false;
        }
        if (tgt == node_id())
        {
            return false;
        }
        auto it = consistSlaves_.begin();
        for (; it != consistSlaves_.end(); ++it)
        {
            if (it->get_slave() == tgt)
            {
                it->set_flags(flags);
                return false;
            }
        }
        consistSlaves_.insert(it, new ConsistEntry(tgt, flags));
        return true;
    }
 
    bool remove_consist(NodeID tgt) override
    {
        for (auto it = consistSlaves_.begin(); it != consistSlaves_.end(); ++it)
        {
            if (it->get_slave() == tgt)
            {
                auto* p = it.operator->();
                consistSlaves_.erase(it);
                delete p;
                return true;
            }
        }
        return false;
    }
 
    NodeID query_consist(int id, uint8_t* flags) override
    {
        int k = 0;
        for (auto it = consistSlaves_.begin();
             it != consistSlaves_.end(); ++it, ++k)
        {
            if (k == id)
            {
                if (flags) *flags = it->get_flags();
                return it->get_slave();
            }
        }
        return 0;
    }
 
    int query_consist_length() override
    {
        int ret = 0;
        for (auto it = consistSlaves_.begin(); it != consistSlaves_.end();
             ++it, ++ret)
        {
        }
        return ret;
    }
 
    TypedQueue<ConsistEntry> consistSlaves_;
};
 
class DefaultTrainNode : public TrainNodeWithConsist
{
public:
    DefaultTrainNode(TrainService *service, TrainImpl *impl);
    ~DefaultTrainNode();
 
    NodeHandle get_controller() override
    {
        return controllerNodeId_;
    }
 
    void set_controller(NodeHandle id) override
    {
        controllerNodeId_ = id;
    }
 
    If *iface() override;
    bool is_initialized() override
    {
        return isInitialized_;
    }
    void set_initialized() override
    {
        isInitialized_ = 1;
    }
    // Used for restarting the stack.
    void clear_initialized() override
    {
        isInitialized_ = 0;
    }
 
    TrainImpl *train() override
    {
        return train_;
    }
 
protected:
    TrainService *service_;
    TrainImpl *train_;
 
private:
    unsigned isInitialized_ : 1;
 
    NodeHandle controllerNodeId_;
};
 
class TrainNodeForProxy : public DefaultTrainNode
{
public:
    TrainNodeForProxy(TrainService *service, TrainImpl *train);
 
    ~TrainNodeForProxy();
 
    NodeID node_id() OVERRIDE;
};
 
class TrainNodeWithId : public DefaultTrainNode
{
public:
    TrainNodeWithId(TrainService *service, TrainImpl *train, NodeID node_id);
 
    ~TrainNodeWithId();
 
    NodeID node_id() OVERRIDE
    {
        return nodeId_;
    }
 
private:
    NodeID nodeId_;
};
 
class TrainService : public Service, private Atomic
{
public:
    TrainService(
        If *iface, NodeRegistry *train_node_registry = new DefaultNodeRegistry);
    ~TrainService();
 
    If *iface()
    {
        return iface_;
    }
 
    void register_train(TrainNode *node);
 
    void unregister_train(TrainNode *node);
 
    bool is_known_train_node(Node *node)
    {
        return nodes_->is_node_registered(node);
    }
 
private:
    struct Impl;
    Impl *impl_;
    If *iface_;
    std::unique_ptr<NodeRegistry> nodes_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_TRACTIONTRAIN_HXX_