feat: small_unique_ptr

Author: vinniefalco

include/boost/capy/small_unique_ptr.hpp

@@ -0,0 +1,255 @@
+//
+// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/capy
+//
+
+#ifndef BOOST_CAPY_SMALL_UNIQUE_PTR_HPP
+#define BOOST_CAPY_SMALL_UNIQUE_PTR_HPP
+
+#include <boost/capy/detail/config.hpp>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <new>
+
+namespace boost {
+namespace capy {
+
+template<class T, std::size_t N = sizeof(T)>
+class small_unique_ptr
+{
+    static_assert(N >= sizeof(T), "Buffer too small for base type");
+
+    template<class U>
+    struct fits_in_buffer
+        : std::integral_constant<
+            bool,
+            (sizeof(U) <= N) &&
+            (alignof(U) <= alignof(std::max_align_t))>
+    {
+    };
+
+    alignas(std::max_align_t) unsigned char buffer_[N];
+    T* ptr_;
+    void (*destroy_)(small_unique_ptr*);
+    void (*relocate_)(small_unique_ptr*, small_unique_ptr*);
+
+    template<class U>
+    static void destroy_small(small_unique_ptr* self)
+    {
+        static_cast<U*>(self->ptr_)->~U();
+    }
+
+    template<class U>
+    static void destroy_large(small_unique_ptr* self)
+    {
+        delete static_cast<U*>(self->ptr_);
+    }
+
+    template<class U>
+    static void relocate_small(
+        small_unique_ptr* src,
+        small_unique_ptr* dst)
+    {
+        static_assert(
+            std::is_nothrow_move_constructible<U>::value,
+            "U must be nothrow move constructible for SBO");
+        U* p = static_cast<U*>(src->ptr_);
+        dst->ptr_ = ::new(static_cast<void*>(&dst->buffer_)) U(std::move(*p));
+        dst->destroy_ = src->destroy_;
+        dst->relocate_ = src->relocate_;
+        p->~U();
+        src->ptr_ = nullptr;
+        src->destroy_ = nullptr;
+        src->relocate_ = nullptr;
+    }
+
+    template<class U>
+    static void relocate_large(
+        small_unique_ptr* src,
+        small_unique_ptr* dst)
+    {
+        dst->ptr_ = src->ptr_;
+        dst->destroy_ = src->destroy_;
+        dst->relocate_ = src->relocate_;
+        src->ptr_ = nullptr;
+        src->destroy_ = nullptr;
+        src->relocate_ = nullptr;
+    }
+
+    void clear() noexcept
+    {
+        ptr_ = nullptr;
+        destroy_ = nullptr;
+        relocate_ = nullptr;
+    }
+
+public:
+    typedef T element_type;
+    typedef T* pointer;
+
+    small_unique_ptr() noexcept
+        : ptr_(nullptr)
+        , destroy_(nullptr)
+        , relocate_(nullptr)
+    {
+    }
+
+    small_unique_ptr(std::nullptr_t) noexcept
+        : small_unique_ptr()
+    {
+    }
+
+    template<class U
+        ,class = typename std::enable_if<
+            std::is_convertible<U*, T*>::value>::type>
+    explicit
+    small_unique_ptr(
+        U* p) noexcept
+        : ptr_(p)
+        , destroy_(p ? &destroy_large<U> : nullptr)
+        , relocate_(p ? &relocate_large<U> : nullptr)
+    {
+    }
+
+    small_unique_ptr(small_unique_ptr const&) = delete;
+    small_unique_ptr& operator=(small_unique_ptr const&) = delete;
+
+    small_unique_ptr(small_unique_ptr&& other) noexcept
+        : ptr_(nullptr)
+        , destroy_(nullptr)
+        , relocate_(nullptr)
+    {
+        if(other.ptr_)
+            other.relocate_(&other, this);
+    }
+
+    small_unique_ptr& operator=(small_unique_ptr&& other) noexcept
+    {
+        if(this != &other)
+        {
+            reset();
+            if(other.ptr_)
+                other.relocate_(&other, this);
+        }
+        return *this;
+    }
+
+    small_unique_ptr& operator=(std::nullptr_t) noexcept
+    {
+        reset();
+        return *this;
+    }
+
+    ~small_unique_ptr() noexcept
+    {
+        reset();
+    }
+
+    void reset() noexcept
+    {
+        if(ptr_)
+        {
+            destroy_(this);
+            clear();
+        }
+    }
+
+    pointer release() noexcept
+    {
+        pointer p = ptr_;
+        clear();
+        return p;
+    }
+
+    pointer get() const noexcept
+    {
+        return ptr_;
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return ptr_ != nullptr;
+    }
+
+    typename std::add_lvalue_reference<T>::type
+    operator*() const noexcept
+    {
+        return *ptr_;
+    }
+
+    pointer operator->() const noexcept
+    {
+        return ptr_;
+    }
+
+    void swap(small_unique_ptr& other) noexcept
+    {
+        small_unique_ptr tmp(std::move(other));
+        other = std::move(*this);
+        *this = std::move(tmp);
+    }
+
+    // SBO path
+    template<class U, class... Args>
+    static
+    typename std::enable_if<
+        fits_in_buffer<U>::value &&
+        std::is_convertible<U*, T*>::value,
+        small_unique_ptr>::type
+    emplace(Args&&... args)
+    {
+        static_assert(
+            std::is_nothrow_move_constructible<U>::value,
+            "U must be nothrow move constructible for SBO");
+        small_unique_ptr p;
+        p.ptr_ = ::new(static_cast<void*>(&p.buffer_)) U(
+            std::forward<Args>(args)...);
+        p.destroy_ = &destroy_small<U>;
+        p.relocate_ = &relocate_small<U>;
+        return p;
+    }
+
+    // Heap path
+    template<class U, class... Args>
+    static
+    typename std::enable_if<
+        !fits_in_buffer<U>::value &&
+        std::is_convertible<U*, T*>::value,
+        small_unique_ptr>::type
+    emplace(Args&&... args)
+    {
+        small_unique_ptr p;
+        p.ptr_ = new U(std::forward<Args>(args)...);
+        p.destroy_ = &destroy_large<U>;
+        p.relocate_ = &relocate_large<U>;
+        return p;
+    }
+};
+
+template<class T, std::size_t N>
+void swap(
+    small_unique_ptr<T, N>& lhs,
+    small_unique_ptr<T, N>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+template<class T, std::size_t N, class U, class... Args>
+typename std::enable_if<
+    std::is_convertible<U*, T*>::value,
+    small_unique_ptr<T, N>>::type
+make_small_unique(Args&&... args)
+{
+    return small_unique_ptr<T, N>::template emplace<U>(
+        std::forward<Args>(args)...);
+}
+
+} // capy
+} // boost
+
+#endif