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;

        virtual const TypeClass GetTypeClass() const = 0;

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

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

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

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

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

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

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

        virtual const std::size_t GetHashCode() const = 0;

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

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

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

        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) {
        }

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

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

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

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

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

#endif //PORYGONLANG_EVALVALUE_HPP