PropertyValue.hpp

#pragma once
 
#include <Infinity/api.h>
 
#include <iostream>
#include <cstdint>
#include <type_traits>
 
namespace Infinity::Types::Core
{
    class Data;
 
    class INFINITY_API_PUBLIC PropertyValue
    {
        public:
            enum Type : uint8_t {
                NIL,
                BOOL,
                INT,
                FLOAT,
                DOUBLE,
                DATA
            };
            
        private:
            Type _type = NIL;
            
            union {
                bool as_bool;
                int as_int;
                float as_float;
                double as_double;
                Data* as_object;
            };
            
        public:
            PropertyValue();
            
            PropertyValue(bool v);
            PropertyValue(int v);
            PropertyValue(float v);
            PropertyValue(double v);
            
            template<typename T, typename = std::enable_if_t<
                 !std::is_same_v<std::decay_t<T>, bool> &&
                 !std::is_same_v<std::decay_t<T>, int> &&
                 !std::is_same_v<std::decay_t<T>, float> &&
                 !std::is_same_v<std::decay_t<T>, double> &&
                 !std::is_same_v<std::decay_t<T>, std::nullptr_t> &&
                 !std::is_pointer_v<std::decay_t<T>> &&
                 !std::is_same_v<std::decay_t<T>, PropertyValue>>>
            PropertyValue(T&& v);
            
            ~PropertyValue();
            
            PropertyValue(const PropertyValue& other);
            
            PropertyValue(PropertyValue&& other) noexcept;
 
            PropertyValue& operator=(const PropertyValue& other);
            PropertyValue& operator=(PropertyValue&& other) noexcept;
            
            Type type() const;
            
            template<typename T>
            T* as();
 
            template<typename T>
            const T* as() const;
 
            void read(std::istream& in);
            void write(std::ostream& out) const;
 
            size_t wrap(const std::byte* data);
            size_t size_bytes() const noexcept;
            
        private:
            void destroy();
        };
}
 
#include <Infinity/Types/Core/PropertyValue.inl>