SchemaAttribute.hpp

#pragma once

#include <QVariant>
#include <unordered_map>
#include <memory>

#include "Hashes.hpp"
#include "Export.hpp"

namespace Showcase
{

  class SchemaAttribute;

  class SchemaAttributeFloat;
  class SchemaAttributeInt;
  class SchemaAttributeString;
  class SchemaAttributeComponent;
  class SchemaAttributeDefault;
  //class SchemaAttributeColor;
  //class SchemaAttributeVector2f;
  //class SchemaAttributeFile;

  typedef std::unordered_map<QByteArray, std::shared_ptr<SchemaAttribute>> SchemaAttributeMap;

  // --------------------------------------------------------------------------

  template <typename T>
  struct Range
  {
    Range();
    Range(T mi, T ma);
    Range(bool boundedBelow, bool boundedAbove, T val);

    bool inside(T val) const;

    void setMin(T val);
    void setMax(T val);

    static Range<T> parseRange(const QVariantMap& map);

    // Order is based on lexicographical order of the range limits.
    // For example: [-1, -0.9] < [-0.999, Inf)
    bool operator==(const Range<T>& other) const;
    bool operator<(const Range<T>& other) const;

    T min;
    T max;
    bool isBoundedBelow;
    bool isBoundedAbove;
  };

  // --------------------------------------------------------------------------

  class SHOWCASE_API SchemaAttribute
  {
  public:
    SchemaAttribute();
    virtual ~SchemaAttribute();

    void setAttributeName(const QByteArray& name);
    const QByteArray& attributeName() const;

    void setDescription(const QString& descr);
    const QString& description() const;

    virtual QString type() const = 0;

    virtual void parseAttributes(const QVariantMap& map);

    static std::shared_ptr<SchemaAttribute> parse(const QVariantMap& map);

  protected:
    QByteArray m_attributeName;
    QString m_description;

  };
  typedef std::shared_ptr<SchemaAttribute> SchemaAttributePtr;

  // --------------------------------------------------------------------------

  template <typename T>
  class SchemaAttributeT : public SchemaAttribute
  {
  public:
    SchemaAttributeT() {}
    virtual ~SchemaAttributeT() {}

    void setDefaultValue(const T& value);
    const T& valueRef() const;
    T value() const;

    bool hasDefaultValue() const;

    virtual void parseAttributes(const QVariantMap& map) override;

  protected:
    T m_defaultValue;
    bool m_hasDefault;
  };

  // --------------------------------------------------------------------------

  template <typename Numeric>
  class SchemaAttributeNumericT : public SchemaAttributeT<Numeric>
  {
  public:
    SchemaAttributeNumericT() {}
    virtual ~SchemaAttributeNumericT() {}

    Range<Numeric> range() const;
    void setRange(Range<Numeric> range);

    virtual void parseAttributes(const QVariantMap& map);

  private:
    Range<Numeric> m_range;
  };

  // --------------------------------------------------------------------------

  class SchemaAttributeFloat : public SchemaAttributeNumericT<float>
  {
  public:
    SchemaAttributeFloat();
    virtual ~SchemaAttributeFloat();

    virtual QString type() const override;
  };

  class SchemaAttributeInt : public SchemaAttributeNumericT<int>
  {
  public:
    SchemaAttributeInt();
    virtual ~SchemaAttributeInt();

    virtual QString type() const override;
  };

  class SchemaAttributeString : public SchemaAttributeT<QString>
  {
  public:
    SchemaAttributeString();
    virtual ~SchemaAttributeString();

    virtual QString type() const override;
  };

  class SchemaAttributeComponent : public SchemaAttributeT<QString>
  {
    typedef std::map<QByteArray, Range<unsigned> > SlotRanges;

  public:
    SchemaAttributeComponent();
    virtual ~SchemaAttributeComponent();

    virtual QString type() const override;

    const QString& componentRole() const;
    Range<unsigned> range() const;
    Range<unsigned> range(const QByteArray & keyword) const;
    const SlotRanges & allRanges() const;

    virtual void parseAttributes(const QVariantMap& map) override;

  private:
    QString m_slotName;
    SlotRanges m_range;
    Range<unsigned> m_defaultRange;
  };

  class SchemaAttributeDefault : public SchemaAttributeT<QString>
  {
  public:
    SchemaAttributeDefault(const QString & type);
    virtual ~SchemaAttributeDefault();

    virtual QString type() const override;

  private:
    QString m_type;
  };

  // --------------------------------------------------------------------------

  template <typename T>
  void SchemaAttributeT<T>::setDefaultValue(const T &value)
  {
    m_defaultValue = value;
    m_hasDefault = true;
  }

  template <typename T>
  const T& SchemaAttributeT<T>::valueRef() const
  {
    return m_defaultValue;
  }

  template <typename T>
  T SchemaAttributeT<T>::value() const
  {
    return m_defaultValue;
  }

  template <typename T>
  bool SchemaAttributeT<T>::hasDefaultValue() const
  {
    return m_hasDefault;
  }

  template <typename T>
  void SchemaAttributeT<T>::parseAttributes(const QVariantMap &map)
  {
    SchemaAttribute::parseAttributes(map);
    auto it = map.find("default");
    if(it != map.end()) {
      setDefaultValue(it.value().value<T>());
    }
  }

  // --------------------------------------------------------------------------

  template <typename T>
  Range<T> SchemaAttributeNumericT<T>::range() const
  {
    return m_range;
  }

  template <typename T>
  void SchemaAttributeNumericT<T>::setRange(Range<T> range)
  {
    m_range = range;
  }

  template <typename T>
  void SchemaAttributeNumericT<T>::parseAttributes(const QVariantMap &map)
  {
    SchemaAttributeT<T>::parseAttributes(map);
    setRange(Range<T>::parseRange(map));
  }

  // --------------------------------------------------------------------------

  template <typename T>
  Range<T>::Range()
    : isBoundedBelow(false),
      isBoundedAbove(false)
  {}

  template <typename T>
  Range<T>::Range(T pmin, T pmax)
    : min(pmin), max(pmax),
      isBoundedBelow(true),
      isBoundedAbove(true)
  {}

  template <typename T>
  Range<T>::Range(bool boundedBelow, bool boundedAbove, T val)
    : isBoundedBelow(boundedBelow),
      isBoundedAbove(boundedAbove)
  {
    if(boundedAbove && boundedBelow)
      min = max = val;
    else if(boundedAbove)
      max = val;
    else if(boundedBelow)
      min = val;
  }

  template <typename T>
  bool Range<T>::inside(T val) const
  {
    if(!isBoundedAbove && !isBoundedBelow) {
      return true;
    } else if(!isBoundedAbove) {
      return val >= min;
    } else if(!isBoundedBelow) {
      return val <= max;
    } else {
      return val <= max && val >= min;
    }
  }

  template <typename T>
  bool Range<T>::operator==(const Range<T>& other) const
  {
    return !(*this < other) && !(other < *this);
  }

  template <typename T>
  bool Range<T>::operator<(const Range<T>& other) const
  {
    return std::make_tuple(isBoundedBelow, min, !isBoundedAbove, max)
        < std::make_tuple(other.isBoundedBelow, other.min, !other.isBoundedAbove, other.max);
  }

  template <typename T>
  void Range<T>::setMin(T val)
  {
    min = val;
    isBoundedBelow = true;
  }

  template <typename T>
  void Range<T>::setMax(T val)
  {
    max = val;
    isBoundedAbove = true;
  }

  template <typename T>
  Range<T> Range<T>::parseRange(const QVariantMap& map)
  {
    Range<T> ran;
    auto it = map.find("min");
    if(it != map.end()) {
      ran.setMin(it.value().value<T>());
    }

    it = map.find("max");
    if(it != map.end()) {
      ran.setMax(it.value().value<T>());
    }

    return ran;
  }

}