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;
    cres_qresult<bool> check(const Value& _value);
    cres_qresult<ValueRange> update(const ValueRange& _range);
    template<typename _T_>
    cres_qresult<bool> check(const _T_& _value);
    ConstrainedValue& apply(const Constraint& _constraint);
    ConstrainedValue& apply(const Value& _value, Type _type);
    template<typename _T_>
    ConstrainedValue& apply(const _T_& _value, Type _type);
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
  template<typename _T_>
  cres_qresult<bool> ConstrainedValue::check(const _T_& _value)
  {
    return check(Value::fromValue(_value));
  }
  template<typename _T_>
  ConstrainedValue& ConstrainedValue::apply(const _T_& _value, Type _type)
  {
    return apply(Value::fromValue(_value), _type);
  }
} // namespace knowCore
 
#include <knowCore/Formatter.h>
 
clog_format_declare_enum_formatter(knowCore::ConstrainedValue::Type, Equal, Different, Inferior,
                                   Superior, InferiorEqual, SuperiorEqual, GeoOverlaps, GeoWithin,
                                   GeoContains, GeoIntersects, Contains, In, NotIn, GeoTouches,
                                   GeoDisjoint, NotContains);
 
clog_format_declare_formatter(knowCore::ConstrainedValue::Constraint)
{
  return format_to(ctx.out(), "{} {}", p.type, p.value);
}
 
clog_format_declare_formatter(knowCore::ConstrainedValue)
{
  return format_to(ctx.out(), "{:s' and '}", p.constraints());
}