mgl_unique_ptr.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_UNIQUE_PTR_H_1743858098
#define INCGUARD_MGL_UNIQUE_PTR_H_1743858098
 
#include <memory>
#include <type_traits>
 
#include <mgl/memory/mgl_memory.h>
#include <mgl/stl/mgl_stl_memory.h>
 
namespace MGL
{
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
template <class T>
class UniquePtr
{
public:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr UniquePtr() noexcept
        : _ptr(nullptr)
    {
    }
 
    // コピーは禁止
    UniquePtr(UniquePtr &) = delete;
    UniquePtr &operator=(UniquePtr &) = delete;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    UniquePtr(UniquePtr &&rhs) noexcept
    {
        Delete();
        _ptr = rhs._ptr;    // NOLINT(cppcoreguidelines-prefer-member-initializer) : Delete()が呼べなくなるので無理
        rhs._ptr = nullptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    UniquePtr &operator=(UniquePtr &&rhs) noexcept
    {
        Delete();
        _ptr = rhs._ptr;
        rhs._ptr = nullptr;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    ~UniquePtr() noexcept
    {
        Delete();
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class U = T, class... Args>
    UniquePtr &New(Args &&...args) noexcept
    {
        // TとUが異なる型、かつ継承関係に無い場合は生成できない
        if constexpr (std::is_class_v<T> && !std::is_same_v<T, U>)
        {
            static_assert(std::is_base_of_v<T, U>, "Cannot be converted to the specified type.");
        }
 
        Delete();
        _ptr = Allocate<U>(std::forward<Args>(args)...);
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class U = T, class Initializer, class... Args>
    UniquePtr &InitNew(Initializer initializer, Args &&...args) noexcept
    {
        // TとUが異なる型、かつ継承関係に無い場合は生成できない
        if constexpr (std::is_class_v<T> && !std::is_same_v<T, U>)
        {
            static_assert(std::is_base_of_v<T, U>, "Cannot be converted to the specified type.");
        }
 
        // 既存のオブジェクトを削除して再生成
        Delete();
        auto obj = Allocate<U>(std::forward<Args>(args)...);
 
        // オブジェクトが生成されていれば初期化関数を呼び出し
        if (obj != nullptr)
        {
            if (!InvokeInitializer(initializer, *obj))
            {
                std::destroy_at(obj);
                MGL::Memory::Deallocate(obj);
                obj = nullptr;
            }
        }
        _ptr = obj;
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    void Delete() noexcept
    {
        if (_ptr != nullptr)
        {
            std::destroy_at(_ptr);
            MGL::Memory::Deallocate(_ptr);
            _ptr = nullptr;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T *Get() const noexcept
    {
        return _ptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T *operator->() const noexcept
    {
        return _ptr;
    }
 
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr std::add_lvalue_reference_t<T> operator*() const noexcept
    {
        return *_ptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsNull() const noexcept
    {
        return _ptr == nullptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool operator!() const noexcept
    {
        return _ptr == nullptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] explicit constexpr operator bool() const noexcept
    {
        return _ptr != nullptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class U = T, class... Args>
    [[nodiscard]] static UniquePtr Make(Args &&...args) noexcept
    {
        // TとUが異なる型、かつ継承関係に無い場合は生成できない
        if constexpr (std::is_class_v<T> && !std::is_same_v<T, U>)
        {
            static_assert(std::is_base_of_v<T, U>, "Cannot be converted to the specified type.");
        }
 
        return UniquePtr(Allocate<U>(std::forward<Args>(args)...));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class U = T, class Initializer, class... Args>
    [[nodiscard]] static UniquePtr InitMake(Initializer initializer, Args &&...args) noexcept
    {
        // TとUが異なる型、かつ継承関係に無い場合は生成できない
        if constexpr (std::is_class_v<T> && !std::is_same_v<T, U>)
        {
            static_assert(std::is_base_of_v<T, U>, "Cannot be converted to the specified type.");
        }
 
        // オブジェクトを生成して初期化関数を呼び出し
        auto obj = Allocate<U>(std::forward<Args>(args)...);
        if (obj != nullptr)
        {
            if (!InvokeInitializer(initializer, *obj))
            {
                std::destroy_at(obj);
                MGL::Memory::Deallocate(obj);
                obj = nullptr;
            }
        }
 
        return UniquePtr(obj);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    std::shared_ptr<T> MoveSharedPtr()
    {
        // シェアードポインタへ渡すデリータ
        auto deleter = [](T *ptr) constexpr
        {
            if (ptr != nullptr)
            {
                std::destroy_at(ptr);
                MGL::Memory::Deallocate(ptr);
            }
        };
 
        // シェアードポインタに渡すアロケータ
        const STL::Allocator<void> allocator;
 
        // デリータとアロケータを使用するシェアードポインタに渡して、自身はnullptrに
        auto sharedPtr = std::shared_ptr<T>(_ptr, deleter, allocator);
        _ptr = nullptr;
 
        return sharedPtr;
    }
 
private:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr UniquePtr(T *ptr) noexcept
        : _ptr(ptr)
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class U, class... Args>
    [[nodiscard]] static U *Allocate(Args &&...args) noexcept
    {
        // クラスオブジェクトを生成
        auto *ptr = MGL::Memory::Allocate(sizeof(U));
        if (ptr == nullptr)
        {
            return nullptr;
        }
 
        // 例外なし
        if constexpr (std::is_nothrow_constructible_v<U, Args...>)
        {
            return new (ptr) U(std::forward<Args>(args)...);
        }
        // 例外あり
        else
        {
            try
            {
                return new (ptr) U(std::forward<Args>(args)...);
            }
            catch (...)
            {
                MGL::Memory::Deallocate(ptr);
            }
        }
 
        return nullptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class U, class Initializer>
    static bool InvokeInitializer(Initializer initializer, U &obj) noexcept
    {
        // 関数がbool型の戻り値を返す場合はその結果を返す
        if constexpr (std::is_invocable_r_v<bool, decltype(initializer), U &>)
        {
            return initializer(obj);
        }
        // 関数の戻り値がvoidなら常にtrue
        else if constexpr (std::is_invocable_r_v<void, decltype(initializer), U &>)
        {
            initializer(obj);
            return true;
        }
        // それ以外は不適格
        else
        {
            static_assert(std::false_type::value, "Initializer must be U& type argument and bool or void value returns.");
            return false;
        }
    }
 
    T *_ptr{nullptr};
};
 
 
// 配列は扱えない
template <class T>
class UniquePtr<T[]>
{
    static_assert(false, "MGL::UniquePtr cannot specification array type.");
};
 
// サイズ付きの配列も扱えない
template <class T, size_t n>
class UniquePtr<T[n]>
{
    static_assert(false, "MGL::UniquePtr cannot specification sized array type.");
};
}    // namespace MGL
 
#endif    // INCGUARD_MGL_UNIQUE_PTR_H_1743858098
 
// vim: et ts=4 sw=4 sts=4