Variant.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "AST/Visitor/Visitor.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    // Helper class to simply cast expressions between boolean, float, and integral types.
    class Variant {
    public:
        using BoolType = bool;
        using IntType = long long;
        using RealType = double;
 
        enum class Types {
            Undefined,
            Bool,
            Int,
            Real,
            Array,
        };
 
        Variant() = default;
        Variant(const Variant&) = default;
        Variant(Variant&&) = default;
        Variant(BoolType value);
        Variant(IntType value);
        Variant(RealType value);
        Variant(const Vector<Variant>& subValues);
        Variant(Vector<Variant>&& subValues);
 
        Variant& operator=(const Variant&) = default;
        Variant& operator=(Variant&&) = default;
 
        Variant& operator+=(const Variant& rhs);
        Variant& operator-=(const Variant& rhs);
        Variant& operator*=(const Variant& rhs);
        Variant& operator/=(const Variant& rhs);
        Variant& operator%=(const Variant& rhs);
        Variant& operator|=(const Variant& rhs);
        Variant& operator&=(const Variant& rhs);
        Variant& operator^=(const Variant& rhs);
        Variant& operator<<=(const Variant& rhs);
        Variant& operator>>=(const Variant& rhs);
        Variant& operator++();
        Variant& operator--();
 
        Variant operator-();
        Variant operator~();
        Variant operator!();
 
        // Converts this variant to a boolean type and returns its value.
        [[nodiscard]] BoolType toBoolean() const;
 
        // Converts this variant to an integral type and returns its value.
        [[nodiscard]] IntType toInteger() const;
 
        // Converts this variant to a real type and returns its value.
        [[nodiscard]] RealType toReal() const;
 
        // Returns -1 if this variant is less than 'rhs', 0 if they are equal, and 1 if this variant is greater than 'rhs'.
        [[nodiscard]] Int32 compareWith(const Variant& rhs) const;
 
        // Returns the sub variant of the array value, or the default variant if this is not an array or the index is out of bounds.
        [[nodiscard]] Variant arraySub(std::size_t idx) const;
 
        // Returns true if this variant is not undefined.
        [[nodiscard]] inline bool isValid() const { return (getType() != Types::Undefined); }
 
        // Returns true if this variant is a boolean type.
        [[nodiscard]] inline bool isBoolean() const { return (getType() == Types::Bool); }
 
        // Returns true if this variant is an integral type.
        [[nodiscard]] inline bool isInteger() const { return (getType() == Types::Int); }
 
        // Returns true if this variant is a real type.
        [[nodiscard]] inline bool isReal() const { return (getType() == Types::Real); }
 
        // Returns true if this variant is an array type.
        [[nodiscard]] inline bool isArray() const { return (getType() == Types::Array); }
 
        // Returns the boolean value.
        [[nodiscard]] inline BoolType getBoolean() const { return mBool; }
 
        // Returns the integral value.
        [[nodiscard]] inline IntType getInteger() const { return mInt; }
 
        // Returns the real value.
        [[nodiscard]] inline RealType getReal() const { return mReal; }
 
        // Returns the array value.
        [[nodiscard]] inline const Vector<Variant>& getArray() const { return mArray; }
 
        // Returns the current internal type of this variant.
        [[nodiscard]] inline Types getType() const { return mType; }
 
        // Shortcut for IsValid().
        inline operator bool() const { return isValid(); }
 
        // Returns a variant, parsed from the specified string (e.g. "true" for a boolean type, or "1.5" for a real type).
        static Variant parseFrom(const String& s);
 
        // Returns the type that is used when two variants are added, subtracted etc.
        static Types findCommonType(const Variant& lhs, const Variant& rhs);
 
        // Returns this variant as string.
        [[nodiscard]] String toString() const;
 
        // Retunrs true if this variant can be represented as a string (see ToString).
        [[nodiscard]] bool isRepresentableAsString() const;
 
    private:
        Types mType = Types::Undefined;
        BoolType mBool = false;
        IntType mInt = 0;
        RealType mReal = 0.0;
        Vector<Variant> mArray;
    };
 
    Variant operator==(const Variant& lhs, const Variant& rhs);
    Variant operator!=(const Variant& lhs, const Variant& rhs);
    Variant operator<(const Variant& lhs, const Variant& rhs);
    Variant operator<=(const Variant& lhs, const Variant& rhs);
    Variant operator>(const Variant& lhs, const Variant& rhs);
    Variant operator>=(const Variant& lhs, const Variant& rhs);
    Variant operator+(const Variant& lhs, const Variant& rhs);
    Variant operator-(const Variant& lhs, const Variant& rhs);
    Variant operator*(const Variant& lhs, const Variant& rhs);
    Variant operator/(const Variant& lhs, const Variant& rhs);
    Variant operator%(const Variant& lhs, const Variant& rhs);
    Variant operator|(const Variant& lhs, const Variant& rhs);
    Variant operator&(const Variant& lhs, const Variant& rhs);
    Variant operator^(const Variant& lhs, const Variant& rhs);
    Variant operator<<(const Variant& lhs, const Variant& rhs);
    Variant operator>>(const Variant& lhs, const Variant& rhs);
 
} // namespace CeresEngine::ShaderCompiler