generic.hpp

#pragma once
 
#include "../core/array.hpp"
#include "../core/string.hpp"
#include <variant>
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
#include <cereal/types/complex.hpp>
#endif
#endif
 
namespace z {
// Default complex type is double.
typedef std::complex<double> cplx;
 
namespace util {
class generic {
public:
    typedef z::core::array<generic> list;
 
private:
    std::variant<bool, long, double, std::complex<double>, zstring, list> value;
 
public:
    enum { VOID, INT, FLOAT, COMPLEX, STRING, ARRAY };
 
    generic() noexcept {}
 
    template <typename INT, typename = typename std::enable_if<std::is_integral<INT>::value, INT>::type>
    generic(INT initVal) noexcept : value(long(initVal)) {}
 
    generic(double initVal) noexcept : value(initVal) {}
 
    generic(const std::complex<double> &initVal) noexcept : value(initVal) {}
 
    generic(const char *initVal) noexcept : value(zstring(initVal)) {}
 
    generic(const wchar_t *initVal) noexcept : value(zstring(initVal)) {}
 
    generic(const zstring &initVal) noexcept : value(initVal) {}
 
    generic(const list &initVal) noexcept : value(initVal) {}
 
    generic(const std::initializer_list<generic> &initVal) noexcept : value(list(initVal)) {}
 
    template <typename INT, typename = typename std::enable_if<std::is_integral<INT>::value, INT>::type>
    explicit inline operator INT() const {
        return integer();
    }
 
    explicit inline operator float() const noexcept {
        return floating();
    }
 
    explicit inline operator double() const noexcept {
        return floating();
    }
 
    long integer() const noexcept;
 
    double floating() const noexcept;
 
    std::complex<double> complex() const noexcept;
 
    zstring toString(bool printArrays = false) const noexcept; // safely cast to string; slow, copies to new string
 
    zstring &string();
 
    const zstring &string() const;
 
    list &array();
 
    const list &array() const;
 
    const list &arrayOr(const list &def) const noexcept;
 
    bool numeric() const noexcept;
 
    bool is(std::size_t type) const noexcept;
 
    int type() const noexcept;
 
    zstring typeString() const noexcept;
 
    int reducesTo(bool castStrings = false) const noexcept; // the lowest we can downcast without losing precision
 
    bool reduce(bool castStrings = false) noexcept;
 
    bool promote(generic *other) noexcept; // promote two numeric values to the same type
 
    generic &operator+=(const generic &other);
 
    generic operator+(const generic &other) const {
        auto tmp = *this;
        return tmp += other;
    }
 
    generic &operator-=(const generic &other);
 
    generic operator-(const generic &other) const {
        auto tmp = *this;
        return tmp -= other;
    }
 
    generic &operator*=(const generic &other);
 
    generic operator*(const generic &other) const {
        auto tmp = *this;
        return tmp *= other;
    }
 
    generic &operator/=(const generic &other);
 
    generic operator/(const generic &other) const {
        auto tmp = *this;
        return tmp /= other;
    }
 
    generic &operator%=(const generic &other);
 
    generic operator%(const generic &other) const {
        auto tmp = *this;
        return tmp %= other;
    }
 
    generic operator-() const;
 
    bool operator==(const generic &other) const;
 
    bool equals(const generic &other) const {
        return operator==(other);
    }
 
    inline bool operator!=(const generic &other) const {
        return !operator==(other);
    }
 
    bool equivalent(const generic &other) const;
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
    template <typename archive>
    void save(archive &ar) const {
        const short int type = this->value.index();
        ar(CEREAL_NVP(type));
 
        if (type == ARRAY) {
            ar(cereal::make_nvp("value", array()));
        } else if (type == STRING) {
            ar(cereal::make_nvp("value", string()));
        } else if (type == COMPLEX) {
            auto val = complex();
            ar(cereal::make_nvp("value", val));
        } else if (type == FLOAT) {
            ar(cereal::make_nvp("value", floating()));
        } else if (type == INT) {
            ar(cereal::make_nvp("value", integer()));
        }
    }
 
    template <class archive>
    void load(archive &ar) {
        short int type = VOID;
        ar(CEREAL_NVP(type));
 
        if (type == ARRAY) {
            list val;
            ar(cereal::make_nvp("value", val));
            value = val;
        } else if (type == STRING) {
            zstring val;
            ar(cereal::make_nvp("value", val));
            value = val;
        } else if (type == COMPLEX) {
            std::complex<double> val;
            ar(cereal::make_nvp("value", val));
            value = val;
        } else if (type == FLOAT) {
            double val;
            ar(cereal::make_nvp("value", val));
            value = val;
        } else if (type == INT) {
            long val;
            ar(cereal::make_nvp("value", val));
            value = val;
        }
    }
#endif
#endif
};
 
} // namespace util
} // namespace z