Condition.h

Go to the documentation of this file.

 
#ifndef INCLUDE_HUEPLUSPLUS_CONDITION_H
#define INCLUDE_HUEPLUSPLUS_CONDITION_H
 
#include "TimePattern.h"
 
#include <nlohmann/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