IOControl/include/IO/Request.h

Go to the documentation of this file.

 
#pragma once
 
#include "Error.h"
#include "DevNode.h"
#include "Event.h"
#include <debug_progmem.h>
 
namespace IO
{
/*
 * IO Commands
 */
#define IOCOMMAND_MAP(XX)                                                                                              \
    XX(undefined, "Undefined or invalid")                                                                              \
    XX(query, "Query node states")                                                                                     \
    XX(off, "Turn node off or set to minimum")                                                                         \
    XX(on, "Turn node on or set to maximum")                                                                           \
    XX(toggle, "Toggle node(s) between on and off")                                                                    \
    XX(latch, "Relay nodes")                                                                                           \
    XX(momentary, "Relay nodes")                                                                                       \
    XX(delay, "Relay nodes")                                                                                           \
    XX(set, "Set value")                                                                                               \
    XX(adjust, "Adjust value")                                                                                         \
    XX(update, "Perform update cycle (e.g. DMX512)")
 
enum class Command {
#define XX(tag, comment) tag,
    IOCOMMAND_MAP(XX)
#undef XX
};
 
} // namespace IO
 
String toString(IO::Command cmd);
bool fromString(IO::Command& cmd, const char* str);
 
namespace IO
{
class Device;
class Request;
 
class Request : public LinkedObjectTemplate<Request>
{
public:
    using OwnedList = OwnedLinkedObjectListTemplate<Request>;
 
    using Callback = Delegate<void(const Request& request)>;
 
    Request(Device& device) : device(device)
    {
        debug_d("Request %p created", this);
    }
 
    // Prevent copying; if required, add `virtual clone()`
    Request(const Request&) = delete;
 
    virtual ~Request()
    {
        debug_d("Request %p (%s) destroyed", this, requestId.c_str());
    }
 
    ErrorCode error() const
    {
        return errorCode;
    }
 
    bool isPending() const
    {
        return errorCode == Error::pending;
    }
 
    String caption() const;
 
    virtual ErrorCode parseJson(JsonObjectConst json);
 
    virtual void submit();
 
    /*
     * Usually called by device or controller, but can also be used to
     * pass a request to its callback first, for example on a configuration
     * error.
     */
    void complete(ErrorCode err);
 
    virtual void getJson(JsonObject json) const;
 
    void setID(const String& value)
    {
        requestId = value;
    }
 
    void setCommand(Command cmd)
    {
        debug_d("setCommand(0x%08x: %s)", cmd, toString(cmd).c_str());
        command = cmd;
    }
 
    void onComplete(Callback callback)
    {
        this->callback = callback;
    }
 
    bool nodeQuery(DevNode node)
    {
        command = Command::query;
        return setNode(node);
    }
 
    bool nodeOff(DevNode node)
    {
        setCommand(Command::off);
        return setNode(node);
    }
 
    bool nodeOn(DevNode node)
    {
        setCommand(Command::on);
        return setNode(node);
    }
 
    bool nodeToggle(DevNode node)
    {
        setCommand(Command::toggle);
        return setNode(node);
    }
 
    bool nodeSet(DevNode node, int value)
    {
        setCommand(Command::set);
        return setNode(node) && setValue(value);
    }
 
    bool nodeAdjust(DevNode node, int value)
    {
        setCommand(Command::adjust);
        return setNode(node) && setValue(value);
    }
    virtual bool setNode(DevNode)
    {
        return false;
    }
 
    virtual bool setValue(int)
    {
        return false;
    }
 
    virtual DevNode::States getNodeStates(DevNode)
    {
        return DevNode::State::unknown;
    }
 
    /*
     * Generic set state command. 0 is off, otherwise on.
     * Dimmable nodes use percentage level 0 - 100.
     */
    virtual bool setNodeState(DevNode node, DevNode::State state)
    {
        if(state == DevNode::State::on) {
            setCommand(Command::on);
        } else if(state == DevNode::State::off) {
            setCommand(Command::off);
        } else {
            return false;
        }
        return setNode(node);
    }
 
    const CString& id() const
    {
        return requestId;
    }
 
    Command getCommand() const
    {
        return command;
    }
 
    virtual void handleEvent(Event event);
 
    Device& device;
 
private:
    Callback callback;
    Command command{Command::undefined}; 
    ErrorCode errorCode{Error::pending};
    CString requestId; 
};
 
} // namespace IO