#ifndef SYMBOL_VALUE_HPP
|
#define SYMBOL_VALUE_HPP
|
|
#include <iostream>
|
#include <stdexcept>
|
#include <string>
|
#include <variant>
|
|
namespace Symbols {
|
|
class Value {
|
public:
|
using Variant = std::variant<int, double, float, std::string, bool>;
|
|
Value() = default;
|
|
Value(int v) : value_(v) {}
|
|
Value(double v) : value_(v) {}
|
|
Value(float v) : value_(v) {}
|
|
Value(const std::string & v) : value_(v) {}
|
|
Value(const char * v) : value_(std::string(v)) {}
|
|
Value(bool v) : value_(v) {}
|
|
const Variant & get() const { return value_; }
|
|
Variant & get() { return value_; }
|
|
template <typename T> T get() const { return std::get<T>(value_); }
|
|
// operator+
|
friend Value operator+(const Value & lhs, const Value & rhs) {
|
return std::visit(
|
[](auto && a, auto && b) -> Value {
|
using A = std::decay_t<decltype(a)>;
|
using B = std::decay_t<decltype(b)>;
|
if constexpr ((std::is_arithmetic_v<A> && std::is_arithmetic_v<B>) ) {
|
return Value{ a + b };
|
} else {
|
throw std::runtime_error("Invalid types for operator+");
|
}
|
},
|
lhs.value_, rhs.value_);
|
}
|
|
// operator==
|
friend bool operator==(const Value & lhs, const Value & rhs) { return lhs.value_ == rhs.value_; }
|
|
// to_string helper (needed for string + int, etc.)
|
static std::string to_string(const Variant & v) {
|
return std::visit(
|
[](auto && val) -> std::string {
|
using T = std::decay_t<decltype(val)>;
|
if constexpr (std::is_same_v<T, bool>) {
|
return val ? "true" : "false";
|
} else if constexpr (std::is_same_v<T, std::string>) {
|
return val;
|
} else {
|
return std::to_string(val);
|
}
|
},
|
v);
|
}
|
|
static std::string to_string(const Value & val) { return to_string(val.value_); }
|
|
private:
|
Variant value_;
|
};
|
|
} // namespace Symbols
|
|
#endif // SYMBOL_VALUE_HPP
|
