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);
};
 
_MISC_FUNC std::ostream& operator<<(std::ostream& os, const Value& v);
 
_MISC_FUNC std::istream& operator>>(std::istream& is, Value& v);
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <misc/gen/Value.hpp>