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
};

String toString(Command cmd);
bool fromString(Command& cmd, const char* str);

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);
    }

    virtual bool nodeAdjust(DevNode node, int value)
    {
        return false;
    }

    virtual bool setNode(DevNode node)
    {
        return false;
    }

    virtual DevNode::States getNodeStates(DevNode node)
    {
        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