pointer.hpp

Go to the documentation of this file.

#pragma once

#include <format>
#include <ostream>
#include <sstream>
#include <utility>

#include "Mountain/core.hpp"
#include "Mountain/utils/reference_counter.hpp"


namespace Mountain
{
    template <typename T>
    class Pointer final
    {
    public:
        using Type = T;

        template <typename... Args>
        static Pointer New(Args&&... args);

        static Pointer New();

        Pointer() = default;

        Pointer(const Pointer& other, bool_t strongReference = false);

        Pointer(Pointer&& other) noexcept;

        // ReSharper disable once CppNonExplicitConvertingConstructor
        Pointer(nullptr_t);

        template <typename U>
        explicit Pointer(const Pointer<U>& other, bool_t strongReference = false);

        template <typename U>
        explicit Pointer(Pointer<U>& other, bool_t strongReference = false);

        template <typename U>
        explicit Pointer(Pointer<U>&& other) noexcept;

        ~Pointer();

        [[nodiscard]]
        Pointer CreateStrongReference() const;

        [[nodiscard]]
        const T* Get() const;

        [[nodiscard]]
        T* Get();

        [[nodiscard]]
        bool_t IsValid() const;

        void ToStrongReference();

        void ToWeakReference();

        [[nodiscard]]
        const ReferenceCounter<T>* GetReferenceCounter() const;

        [[nodiscard]]
        bool_t GetIsStrongReference() const;

        void Reset();

        Pointer& operator=(const Pointer& other);

        Pointer& operator=(Pointer&& other) noexcept;

        Pointer& operator=(nullptr_t);

        template <typename U>
        Pointer& operator=(const Pointer<U>& other);

        template <typename U>
        Pointer& operator=(Pointer<U>&& other) noexcept;

        [[nodiscard]]
        explicit operator const T*() const;

        [[nodiscard]]
        explicit operator T*();

        // ReSharper disable once CppNonExplicitConversionOperator
        [[nodiscard]]
        operator bool_t() const;

        [[nodiscard]]
        T& operator*();

        [[nodiscard]]
        const T& operator*() const;

        [[nodiscard]]
        T* operator->();

        [[nodiscard]]
        const T* operator->() const;

    private:
        ReferenceCounter<T>* m_ReferenceCounter = nullptr;

        bool_t m_IsStrongReference = false;

        explicit Pointer(ReferenceCounter<T>*&& referenceCounter, bool_t strongReference);

        void SetReferenceCounter(ReferenceCounter<T>* newReferenceCounter);

        void CheckReferenceCounterValid();
    };
}

#include "Mountain/utils/pointer.inl"

template <typename T>
struct std::formatter<Mountain::Pointer<T>>  // NOLINT(cert-dcl58-cpp)
{
    template <class ParseContext>
    constexpr typename ParseContext::iterator parse(ParseContext& ctx)
    {
        auto it = ctx.begin();
        if (it == ctx.end())
            return it;
 
        if (*it != '}')
            throw std::format_error("Invalid format args for Mountain::Pointer");
 
        return it;
    }

    // ReSharper disable once CppMemberFunctionMayBeStatic
    template <class FormatContext>
    typename FormatContext::iterator format(const Mountain::Pointer<T>& pointer, FormatContext& ctx) const
    {
        std::ostringstream out;
        
        out << "0x" << static_cast<const T*>(pointer);
        
        return std::ranges::copy(std::move(out).str(), ctx.out()).out;
    }
};

template<typename T>
struct std::hash<Mountain::Pointer<T>>  // NOLINT(cert-dcl58-cpp)
{
    std::size_t operator()(const Mountain::Pointer<T>& p) const noexcept
    {
        const std::size_t h1 = std::hash<decltype(p.GetReferenceCounter())>{}(const_cast<decltype(p.GetReferenceCounter())>(p.GetReferenceCounter()));
        const std::size_t h2 = std::hash<bool_t>{}(p.GetIsStrongReference());
        return h1 ^ (h2 << 1);
    }
};