Value.h

Go to the documentation of this file.

#pragma once
 
#include <misc/gen/TVector.h>
#include <misc/global.h>
#if IS_QT
  #include <QString>
#endif
#include <limits>
 
namespace sf
{
 
class _MISC_CLASS Value
{
  public:
    typedef int64_t int_type;
    typedef double flt_type;
 
    enum EType
    {
      vitReference = -1,
      vitInvalid = 0,
      vitUndefined,
      vitInteger,
      vitFloat,
      vitString,
      vitBinary,
      vitCustom,
    };
 
    Value();
 
    Value& operator=(Value&&) noexcept;
 
    Value(Value&&) noexcept;
 
    Value(const Value& v);
 
    explicit Value(const Value* v);
 
    explicit Value(EType type);
 
    explicit Value(flt_type v);
 
    explicit Value(const char* v);
 
    explicit Value(const std::string& v);
 
#if IS_QT
 
    explicit Value(const QString& v);
 
#endif
 
    explicit Value(bool v);
 
    explicit Value(int v);
 
#if IS_WIN
    explicit Value(long v);
#endif
 
    explicit Value(unsigned v);
 
    explicit Value(int_type v);
 
    Value(const void* v, size_t size);
 
    Value(EType type, const void* content, size_t size = 0);
 
    ~Value();
 
    inline Value& set(const Value* v);
 
    Value& set(const Value& v);
 
    inline Value& set(bool v);
 
    inline Value& set(int v);
 
#if IS_WIN
    Value& set(long v);
#endif
 
    inline Value& set(unsigned v);
 
    inline Value& set(int_type v);
 
    inline Value& set(flt_type v);
 
    inline Value& set(const char* v);
 
    inline Value& set(const std::string& v);
 
#if IS_QT
 
    inline Value& set(const QString& qs);
 
#endif
 
    Value& set(int type, const void* content, size_t size = 0);
 
    inline Value& set(const void* v, size_t size);
 
    Value& assign(const Value& v);
 
    inline Value& assign(bool v);
 
    inline Value& assign(int v);
 
    inline Value& assign(unsigned v);
 
#if IS_WIN
    Value& assign(const long v);
#endif
 
    inline Value& assign(flt_type v);
 
    inline Value& assign(const char* v);
 
    inline Value& assign(const std::string& v);
 
#if IS_QT
 
    inline Value& assign(const QString& s);
 
#endif
 
    inline Value& assign(const void* v, size_t size);
 
    [[nodiscard]] inline EType getType() const;
 
    [[nodiscard]] static EType getType(const std::string_view& type);
 
    [[nodiscard]] static std::string_view getType(EType type);
 
    bool setType(EType type);
 
    [[nodiscard]] bool isValid() const;
 
    [[nodiscard]] bool isNumber() const;
 
    flt_type getFloat(int* cnv_err) const;
 
    [[nodiscard]] flt_type getFloat() const;
 
    int_type getInteger(int* cnv_err) const;
 
    [[nodiscard]] int_type getInteger() const;
 
    [[nodiscard]] size_t getSize() const;
 
    [[nodiscard]] const void* getBinary() const;
 
    [[nodiscard]] const char* getData() const;
 
    [[nodiscard]] std::string getString(int precision = std::numeric_limits<int>::max()) const;
 
#if IS_QT
 
    [[nodiscard]] QString getQString(int precision = std::numeric_limits<int>::max()) const;
 
#endif
 
    Value& round(const Value& v);
 
    [[nodiscard]] bool isZero() const;
 
#if IS_QT
 
    Value& operator=(const QString& v);
 
    explicit operator QString() const;
 
#endif
 
    explicit operator std::string() const;
 
    explicit operator bool() const;
 
    bool operator!() const;
 
    int operator==(const Value& v) const;
 
    int operator!=(const Value& v) const;
 
    int operator>(const Value& v) const;
 
    int operator>=(const Value& v) const;
 
    int operator<(const Value& v) const;
 
    int operator<=(const Value& v) const;
 
    Value& operator*=(const Value& v);
 
    Value& operator/=(const Value& v);
 
    Value& operator%=(const Value& v);
 
    Value& operator+=(const Value& v);
 
    Value& operator-=(const Value& v);
 
    Value& operator=(const Value& v);
 
    Value& operator=(const std::string& v);
 
    Value& operator=(const Value* v);
 
    static Value calculateOffset(Value value, Value min, Value max, const Value& len, bool clip);
 
    enum
    {
      maxString = 0xFFFF,
      maxBinary = 0xFFFF,
      maxCustom = 0xFFFF
    };
 
    [[nodiscard]] Value mul(const Value& v) const;
 
    [[nodiscard]] Value div(const Value& v) const;
 
    [[nodiscard]] Value add(const Value& v) const;
 
    [[nodiscard]] Value sub(const Value& v) const;
 
    [[nodiscard]] Value mod(const Value& v) const;
 
    [[nodiscard]] int compare(const Value& v) const;
 
  private:
    void makeInvalid();
 
    EType _type{vitUndefined};
 
    size_t _size{0};
 
    union
    {
        char* _ptr;
        flt_type _flt;
        int_type _int;
        Value* _ref;
    } _data{nullptr};
 
    static const size_t _sizeExtra;
 
    static const char* _typeNames[];
 
  public:
    static const char* _invalidStr;
    typedef TVector<Value> vector_type;
 
    friend Value operator*(const Value& v1, const Value& v2);
    friend Value operator/(const Value& v1, const Value& v2);
    friend Value operator%(const Value& v1, const Value& v2);
    friend Value operator+(const Value& v1, const Value& v2);
    friend Value operator-(const Value& v1, const Value& v2);
    friend std::ostream& operator<<(std::ostream& os, const Value& v);
    friend std::istream& operator>>(std::istream& is, Value& v);
};
 
inline Value& Value::set(bool v)
{
  return set(static_cast<int_type>(v));
}
 
inline Value& Value::set(int v)
{
  return set(static_cast<int_type>(v));
}
 
#if IS_WIN
inline Value& Value::set(long v)
{
  return set(int_type(v));
}
#endif
 
inline Value& Value::set(unsigned v)
{
  return set(static_cast<int_type>(v));
}
 
inline Value& Value::set(int64_t v)
{
  return set(vitInteger, &v);
}
 
inline Value& Value::set(flt_type v)
{
  return set(vitFloat, &v);
}
 
inline Value& Value::set(const char* v)
{
  return set(vitString, v);
}
 
inline Value& Value::set(const std::string& v)
{
  return set(vitString, v.data());
}
 
#if IS_QT
 
inline Value& Value::set(const QString& qs)
{
  return set(qs.toStdString());
}
 
inline QString Value::getQString(int precision) const
{
  return QString::fromStdString(getString(precision));
}
 
#endif
 
inline Value& Value::set(const void* v, size_t size)
{
  return set(vitBinary, v, size);
}
 
inline Value& Value::assign(const bool v)
{
  const int_type i = v;
  return assign(&i, sizeof(int_type));
}
 
inline Value& Value::assign(const int v)
{
  const int_type i = v;
  return assign(&i, sizeof(int_type));
}
 
inline Value& Value::assign(const unsigned v)
{
  const int_type i = v;
  return assign(&i, sizeof(int_type));
}
 
#if IS_WIN
inline Value& Value::assign(const long v)
{
  return assign(Value(v));
}
#endif
 
inline Value& Value::assign(const flt_type v)
{
  return assign(Value(v));
}
 
inline Value& Value::assign(const char* v)
{
  return assign(Value(v));
}
 
inline Value& Value::assign(const std::string& v)
{
  return assign(Value(v));
}
 
#if IS_QT
 
inline Value& Value::assign(const QString& s)
{
  return assign(Value(s));
}
 
#endif
 
inline Value& Value::assign(const void* v, size_t size)
{
  return assign(Value(v, size));
}
 
inline Value::EType Value::getType() const
{
  return _type == vitReference ? _data._ref->getType() : _type;
}
 
inline bool Value::isValid() const
{
  return _type == vitReference ? _data._ref->isValid() : _type != vitInvalid;
}
 
inline bool Value::isNumber() const
{
  return _type == vitReference ? _data._ref->isNumber() : _type == vitInteger || _type == vitFloat;
}
 
inline size_t Value::getSize() const
{
  return _type == vitReference ? _data._ref->getSize() : _size;
}
 
inline Value::operator bool() const
{
  return !isZero();
}
 
inline bool Value::operator!() const
{
  return !isZero();
}
 
inline Value::operator std::string() const
{
  return getString();
}
 
inline int Value::operator==(const Value& v) const
{
  return !compare(v);
}
 
inline int Value::operator!=(const Value& v) const
{
  return compare(v) != 0;
}
 
inline int Value::operator>(const Value& v) const
{
  return compare(v) > 0;
}
 
inline int Value::operator>=(const Value& v) const
{
  return compare(v) >= 0;
}
 
inline int Value::operator<(const Value& v) const
{
  return compare(v) < 0;
}
 
inline int Value::operator<=(const Value& v) const
{
  return compare(v) <= 0;
}
 
inline Value& Value::operator*=(const Value& v)
{
  return assign(mul(v));
}
 
inline Value& Value::operator/=(const Value& v)
{
  return assign(div(v));
}
 
inline Value& Value::operator%=(const Value& v)
{
  return assign(mod(v));
}
 
inline Value& Value::operator+=(const Value& v)
{
  return assign(add(v));
}
 
inline Value& Value::operator-=(const Value& v)
{
  return assign(sub(v));
}
 
inline Value& Value::operator=(const Value& v)
{
  assign(v);
  return *this;
}
 
inline Value& Value::operator=(const std::string& v)
{
  assign(v);
  return *this;
}
 
#if IS_QT
 
inline Value& Value::operator=(const QString& v)
{
  assign(v);
  return *this;
}
 
#endif
 
inline Value& Value::operator=(const Value* v)
{
  set(v);
  return *this;
}
 
inline Value& Value::set(const Value* v)
{
  return set(vitReference, v);
}
 
inline Value::flt_type Value::getFloat() const
{
  return getFloat(nullptr);
}
 
inline Value::int_type Value::getInteger() const
{
  return getInteger(nullptr);
}
 
inline Value operator*(const Value& v1, const Value& v2)
{
  return v1.mul(v2);
}
 
inline Value operator/(const Value& v1, const Value& v2)
{
  return v1.div(v2);
}
 
inline Value operator%(const Value& v1, const Value& v2)
{
  return v1.mod(v2);
}
 
inline Value operator+(const Value& v1, const Value& v2)
{
  return v1.add(v2);
}
 
inline Value operator-(const Value& v1, const Value& v2)
{
  return v1.sub(v2);
}
 
_MISC_FUNC std::ostream& operator<<(std::ostream& os, const Value& v);
 
_MISC_FUNC std::istream& operator>>(std::istream& is, Value& v);
 
}// namespace sf