TAnyPtr.h

Go to the documentation of this file.

#pragma once
 
#include <utility>
#include <cstddef>
#include <type_traits>
#include <typeindex>
 
namespace ph
{
 
template<bool IS_CONST>
class TAnyPtr final
{
public:
    TAnyPtr();
 
    TAnyPtr(std::nullptr_t ptr);
 
    template<typename T>
    TAnyPtr(T* ptr);
 
    template<typename T>
    auto* get() const;
 
    operator bool () const;
 
    template<typename T>
    operator T* () const;
 
private:
    using PointerType = std::conditional_t<IS_CONST, const void*, void*>;
 
    PointerType m_pointer;
    std::type_index m_pointedType;
};
 
using AnyConstPtr = TAnyPtr<true>;
 
using AnyNonConstPtr = TAnyPtr<false>;
 
template<bool IS_CONST>
inline TAnyPtr<IS_CONST>::TAnyPtr()
    : TAnyPtr(nullptr)
{}
inline TAnyPtr<IS_CONST>::TAnyPtr() {…}
 
template<bool IS_CONST>
inline TAnyPtr<IS_CONST>::TAnyPtr(std::nullptr_t /* ptr */)
    : m_pointer(nullptr)
    , m_pointedType(typeid(std::nullptr_t))
{}
inline TAnyPtr<IS_CONST>::TAnyPtr(std::nullptr_t /* ptr */) {…}
 
template<bool IS_CONST>
template<typename T>
inline TAnyPtr<IS_CONST>::TAnyPtr(T* const ptr)
    : m_pointer(ptr)
    , m_pointedType(typeid(T))
{
    static_assert(sizeof(T) == sizeof(T),
        "Input must be a complete type.");
}
inline TAnyPtr<IS_CONST>::TAnyPtr(T* const ptr) {…}
 
template<bool IS_CONST>
template<typename T>
inline auto* TAnyPtr<IS_CONST>::get() const
{
    // Also handles the case where `const` is explicitly specified in `T`
    using ReturnType = std::conditional_t<IS_CONST, const T, T>;
 
    // Important: type must be exactly equal for the cast to have defined behavior
    if(m_pointedType == typeid(T))
    {
        return static_cast<ReturnType*>(m_pointer);
    }
    else
    {
        return static_cast<ReturnType*>(nullptr);
    }
}
inline auto* TAnyPtr<IS_CONST>::get() const {…}
 
template<bool IS_CONST>
inline TAnyPtr<IS_CONST>::operator bool () const
{
    return m_pointer != nullptr;
}
inline TAnyPtr<IS_CONST>::operator bool () const {…}
 
template<bool IS_CONST>
template<typename T>
inline TAnyPtr<IS_CONST>::operator T* () const
{
    // Note that we could, of course, write a better return type that matches `IS_CONST`. Here a more
    // general type `T*` is used, so we could detect potential conversion errors here and provide
    // a more friendly error message.
    //
    static_assert(!(IS_CONST && !std::is_const_v<T>),
        "Cannot convert a const pointer to non-const.");
 
    return get<T>();
}
inline TAnyPtr<IS_CONST>::operator T* () const {…}
    operator T* () const; {…}
 
}// end namespace ph
    operator bool () const; {…}
    auto* get() const; {…}
    TAnyPtr(T* ptr); {…}
    TAnyPtr(std::nullptr_t ptr); {…}
    TAnyPtr(); {…}
class TAnyPtr final {…};