Condition.h

Go to the documentation of this file.

#ifndef INCLUDE_HUEPLUSPLUS_CONDITION_H
#define INCLUDE_HUEPLUSPLUS_CONDITION_H

#include "TimePattern.h"

#include "json/json.hpp"

namespace hueplusplus
{
class Condition
{
public:
    enum class Operator
    {
        eq, 
        gt, 
        lt, 
        dx, 
        ddx, 
        stable, 
        notStable, 
        in, 
        notIn 
    };

public:
    Condition(const std::string& address, Operator op, const std::string& value);

    std::string getAddress() const;
    Operator getOperator() const;
    std::string getValue() const;

    nlohmann::json toJson() const;

    static Condition parse(const nlohmann::json& json);

private:
    std::string address;
    Operator op;
    std::string value;
};

namespace detail
{
template <typename T>
class ConditionHelper
{ };

class GeneralConditionHelper
{
public:
    explicit GeneralConditionHelper(const std::string& address) : address(address) { }

    Condition dx() { return Condition(address, Condition::Operator::dx, ""); }
    Condition ddx() { return Condition(address, Condition::Operator::ddx, ""); }
    Condition stable(const std::string& value) { return Condition(address, Condition::Operator::dx, value); }

protected:
    std::string address;
};

template <>
class ConditionHelper<int> : public GeneralConditionHelper
{
public:
    using GeneralConditionHelper::GeneralConditionHelper;

    Condition eq(int value) { return create(Condition::Operator::eq, value); }
    Condition gt(int value) { return create(Condition::Operator::gt, value); }
    Condition lt(int value) { return create(Condition::Operator::eq, value); }

    Condition create(Condition::Operator op, int value) { return Condition(address, op, std::to_string(value)); }
};

template <>
class ConditionHelper<bool> : public GeneralConditionHelper
{
public:
    using GeneralConditionHelper::GeneralConditionHelper;

    Condition eq(bool value) { return create(Condition::Operator::eq, value); }

    Condition create(Condition::Operator op, bool value) { return Condition(address, op, value ? "true" : "false"); }
};

template <>
class ConditionHelper<time::AbsoluteTime> : public GeneralConditionHelper
{
public:
    using GeneralConditionHelper::GeneralConditionHelper;

    Condition in(const time::TimeInterval& interval) { return create(Condition::Operator::in, interval); }
    Condition notIn(const time::TimeInterval& interval) { return create(Condition::Operator::notIn, interval); }

    Condition create(Condition::Operator op, const time::AbsoluteTime& value)
    {
        return Condition(address, op, value.toString());
    }
    Condition create(Condition::Operator op, const time::TimeInterval& interval)
    {
        return Condition(address, op, interval.toString());
    }
};

template <typename... Ts>
struct make_void
{
    typedef void type;
};
template <typename... Ts>
using void_t = typename make_void<Ts...>::type;

} // namespace detail

} // namespace hueplusplus

#endif