DccAccyProducer.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_DCCACCYPRODUCER_HXX_
#define _OPENLCB_DCCACCYPRODUCER_HXX_
 
#include <vector>
 
#include "executor/CallableFlow.hxx"
#include "openlcb/NonAuthoritativeEventProducer.hxx"
#include "openlcb/TractionDefs.hxx"
#include "utils/Uninitialized.hxx"
 
namespace openlcb
{
struct DccAccyProducerCommands
{
    enum Query
    {
        QUERY, 
    };
 
    enum Set
    {
        SET, 
    };
};
 
struct DccAccyProducerInput : public CallableFlowRequestBase
{
    enum Command
    {
        CMD_QUERY, 
        CMD_SET, 
    };
 
    void reset(const DccAccyProducerCommands::Query &,
               const uint16_t address)
    {
        cmd_ = CMD_QUERY;
        address_ = address;
    }
 
    void reset(const DccAccyProducerCommands::Set &, const uint16_t address,
               bool value)
    {
        cmd_ = CMD_SET;
        address_ = address;
        value_ = value;
    }
 
    Command cmd_; 
    uint16_t address_; 
    bool value_; 
};
 
class DccAccyProducer : public CallableFlow<DccAccyProducerInput>
{
public:
    enum Route
    {
        NORMAL = false, 
        REVERSE = true, 
    };
 
    static constexpr uint16_t MAX_ADDRESS = 2044;
 
    DccAccyProducer(Node *node,
               std::function<void(unsigned, bool)> dcc_state_callback = nullptr)
        : CallableFlow<DccAccyProducerInput>(node->iface())
        , dccStateCallback_(dcc_state_callback)
        , writer_()
        , bn_()
    {
        once_.once();
        AtomicHolder h(&instancesLock_);
        if (instances_->empty())
        {
            uint32_t max_address = MAX_ADDRESS;
            eventProducer_.emplace(
                      node,
                      TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE + 8,
                      max_address, state_callback);
        }
        instances_->push_back(this);
    }
 
    ~DccAccyProducer()
    {
        AtomicHolder h(&instancesLock_);
        for (unsigned i = 0; i < instances_->size(); ++i)
        {
            if (instances_->at(i) == this)
            {
                instances_->erase(instances_->begin() + i);
                break;
            }
        }
        if (instances_->empty())
        {
            eventProducer_.reset();
        }
    }
 
private:
    using Command = DccAccyProducerInput::Command;
 
    static void once_routine()
    {
        instances_.emplace();
    }
 
    Action entry() override
    {
        HASSERT(input()->address_ > 0 && input()->address_ <= MAX_ADDRESS);
        switch (input()->cmd_)
        {
            case Command::CMD_QUERY:
                return call_immediately(STATE(query));
            case Command::CMD_SET:
                return call_immediately(STATE(set));
            default:
                return return_with_error(Defs::ERROR_INVALID_ARGS);
        }
    }
 
    Action query()
    {
        eventProducer_->send_query_consumer(input()->address_ - 1, &writer_,
                                            bn_.reset(this));
        return wait_and_return_ok();
    }
 
    Action set()
    {
        eventProducer_->set(input()->address_ - 1, input()->value_, &writer_,
                            bn_.reset(this));
        return wait_and_return_ok();
    }
 
    DccAccyProducerInput *input()
    {
        return message()->data();
    }
 
    static void state_callback(unsigned bit, bool value)
    {
        for (unsigned i = 0; i < instances_->size(); ++i)
        {
            if (instances_->at(i)->dccStateCallback_)
            {
                instances_->at(i)->dccStateCallback_(bit + 1, value);
            }
        }
    }
 
    static uninitialized<BitRangeNonAuthoritativeEventP> eventProducer_;
 
    static uninitialized<std::vector<DccAccyProducer*>> instances_;
 
    static Atomic instancesLock_;
 
    static OSThreadOnce once_;
 
    std::function<void(unsigned, bool)> dccStateCallback_;
 
    WriteHelper writer_; 
    BarrierNotifiable bn_; 
 
    DISALLOW_COPY_AND_ASSIGN(DccAccyProducer);
};
 
} // namespace openlcb
 
#endif // _OPENLCB_DCCACCYPRODUCER_HXX_