PorygonLang/src/Evaluator/EvalValues/EvalValue.hpp

#ifndef PORYGONLANG_EVALVALUE_HPP
#define PORYGONLANG_EVALVALUE_HPP

#include <string>
#include <sstream>
#include <memory>
#include "../../ScriptType.hpp"
#include "../EvaluationException.hpp"
namespace Porygon::Evaluation{
    class EvalValue;
    class Iterator;
}
#include "../Iterator/Iterator.hpp"


namespace Porygon::Evaluation {
    class EvalValue {
    public:
        EvalValue() = default;

        virtual ~EvalValue() = default;

        [[nodiscard]]
        virtual TypeClass GetTypeClass() const = 0;

        [[nodiscard]]
        virtual bool operator==(const EvalValue *b) const = 0;

        [[nodiscard]]
        virtual bool operator!=(const EvalValue *b) const {
            return !(this->operator==(b));
        }

        [[nodiscard]]
        virtual shared_ptr<const EvalValue> Clone() const = 0;

        [[nodiscard]]
        virtual long EvaluateInteger() const {
            throw EvaluationException("Can't evaluate this EvalValue as integer.");
        }

        [[nodiscard]]
        virtual double EvaluateFloat() const {
            throw EvaluationException("Can't evaluate this EvalValue as float.");
        }

        [[nodiscard]]
        virtual bool EvaluateBool() const {
            throw EvaluationException("Can't evaluate this EvalValue as bool.");
        }

        [[nodiscard]]
        virtual std::u16string EvaluateString() const {
            throw EvaluationException("Can't evaluate this EvalValue as string.");
        }

        [[nodiscard]]
        virtual std::size_t GetHashCode() const = 0;

        [[nodiscard]]
        virtual shared_ptr<const EvalValue> IndexValue(const EvalValue *val) const {
            throw EvaluationException("Can't index this EvalValue");
        }

        [[nodiscard]]
        virtual shared_ptr<const EvalValue> IndexValue(uint32_t hash) const {
            throw EvaluationException("Can't index this EvalValue");
        }

        virtual void SetIndexValue(const EvalValue *key, const shared_ptr<const EvalValue> &value) const {
            throw EvaluationException("Can't index this EvalValue");
        }

        [[nodiscard]]
        virtual Iterator * GetKeyIterator() const{
            throw EvaluationException("Can't iterate over this EvalValue");
        }
    };

    class BooleanEvalValue : public EvalValue {
        const bool _value;
    public:
        explicit BooleanEvalValue(bool val)
                : _value(val) {
        }

        [[nodiscard]]
        inline shared_ptr<const EvalValue> Clone() const final {
            return make_shared<BooleanEvalValue>(_value);
        }

        [[nodiscard]]
        inline TypeClass GetTypeClass() const final {
            return TypeClass::Bool;
        }

        [[nodiscard]]
        inline bool EvaluateBool() const final {
            return _value;
        }

        [[nodiscard]]
        bool operator==(const EvalValue *b) const final {
            if (b->GetTypeClass() != TypeClass::Bool)
                return false;
            return this->EvaluateBool() == b->EvaluateBool();
        };

        [[nodiscard]]
        inline std::size_t GetHashCode() const final {
            return _value;
        }
    };
}

#endif //PORYGONLANG_EVALVALUE_HPP