VariableBase.h

 
#pragma once
 
#include <cassert>
#include <utility>      //std::forward, std::move
#include <type_traits>  //std::is_rvalue_reference_v, std::is_lvalue_reference_v, std::is_const_v...
 
#include "Refureku/TypeInfo/Entity/Entity.h"
#include "Refureku/TypeInfo/Type.h"
 
namespace rfk
{
    class VariableBase : public Entity
    {
        public:
            REFUREKU_API Type const& getType() const noexcept;
 
        protected:
            //Forward declaration
            class VariableBaseImpl;
 
            template <typename T>
            static constexpr bool is_value_v = !std::is_lvalue_reference_v<T> && !std::is_rvalue_reference_v<T>;
 
            REFUREKU_INTERNAL VariableBase(VariableBaseImpl* implementation)    noexcept;
            REFUREKU_INTERNAL VariableBase(VariableBase&&)                      noexcept;
            REFUREKU_INTERNAL ~VariableBase()                                   noexcept;
 
            RFK_GEN_GET_PIMPL(VariableBaseImpl, Entity::getPimpl())
 
            template <typename ValueType>
            RFK_NODISCARD ValueType                 get(void* ptr)              const;
 
            template <typename ValueType>
            RFK_NODISCARD ValueType                 get(void const* ptr)        const;
 
            template <typename ValueType>
            void                                    set(void*       ptr,
                                                        ValueType&& value)      const;
 
            REFUREKU_INTERNAL void                  set(void*       target,
                                                        void const* source,
                                                        std::size_t bytesCount) const;
 
            RFK_NORETURN REFUREKU_API static void   throwConstViolationException(char const* message);
    };
 
    #include "Refureku/TypeInfo/Variables/VariableBase.inl"
}