ConstrainedValue.h

#pragma once
 
#include <QSharedDataPointer>
 
#include "Value.h"
 
namespace knowCore
{
  class ConstrainedValue
  {
  public:
    enum class Type
    {
      Equal,
      Different,
      Inferior, 
      Superior, 
      InferiorEqual, 
      SuperiorEqual, 
      GeoOverlaps, 
      GeoWithin, 
      GeoContains, 
      GeoIntersects, 
      GeoTouches, 
      GeoDisjoint, 
      Contains, 
      NotContains, 
      In, 
      NotIn 
    };
    struct Constraint
    {
      Value value;
      Type type;
      bool operator==(const Constraint& _rhs) const {
        return value == _rhs.value and type == _rhs.type;
      }
      bool operator!=(const Constraint& _rhs) const {
        return not(*this == _rhs);
      }
    };
  public:
    ConstrainedValue();
    ConstrainedValue(const ConstrainedValue& _rhs);
    ConstrainedValue& operator=(const ConstrainedValue& _rhs);
    ~ConstrainedValue();
    
    bool operator==(const ConstrainedValue& _value) const;
    
    bool hasConstraints() const;
    QList<Constraint> constraints() const;
    knowCore::ReturnValue<bool> check(const Value& _value);
    knowCore::ReturnValue<ValueRange> update(const ValueRange& _range);
    template<typename _T_>
    knowCore::ReturnValue<bool> check(const _T_& _value);
    ConstrainedValue& apply(const Constraint& _constraint);
    ConstrainedValue& apply(const Value& _value, Type _type);
    template<typename _T_>
    knowCore::ReturnVoid apply(const _T_& _value, Type _type);
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  template<typename _T_>
  knowCore::ReturnValue<bool> ConstrainedValue::check(const _T_& _value)
  {
    return check(Value::fromValue(_value));
  }
  template<typename _T_>
  knowCore::ReturnVoid ConstrainedValue::apply(const _T_& _value, Type _type)
  {
    apply(Value::fromValue(_value), _type);
    return kCrvSuccess();
  }
}
 
#include <knowCore/Formatter.h>
 
KNOWCORE_CORE_DECLARE_FORMATTER_ENUM(knowCore::ConstrainedValue::Type, Equal, Different, Inferior, Superior, InferiorEqual, SuperiorEqual, GeoOverlaps, GeoWithin, GeoContains, GeoIntersects, Contains, In);
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowCore::ConstrainedValue::Constraint)
{
  return format_to(ctx.out(), "{} {}", p.type, p.value);
}
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowCore::ConstrainedValue)
{
  return format_to(ctx.out(), "{}", fmt::join(p.constraints(), " and "));
}