eonix/gblibstdc++/include/memory

#ifndef __GBLIBCPP_MEMORY__
#define __GBLIBCPP_MEMORY__

#include <bits/compressed_pair>
#include <cstddef>
#include <new>
#include <type_traits>
#include <utility>

namespace std {

template <typename T>
constexpr T* addressof(T& arg) noexcept
{
    return __builtin_addressof(arg);
}

// template <typename T>
// constexpr enable_if_t<is_function_v<remove_reference_t<T>>, T*>
// addressof(T& arg) noexcept
// {
//     return &arg;
// }

// template <typename T>
// constexpr enable_if_t<!is_function_v<remove_reference_t<T>>, T*>
// addressof(T& arg) noexcept
// {
//     return reinterpret_cast<T*>(
//         &const_cast<char&>(
//             reinterpret_cast<const volatile char&>(arg)
//         )
//     );
// }

template <typename T>
const T* addressof(const T&&) = delete;

namespace __helpers {

template <typename Ptr, typename = void>
struct pointer_difference_type
{ using type = std::ptrdiff_t; };

template <typename Ptr>
struct pointer_difference_type<Ptr,
    std::void_t<typename Ptr::difference_type>>
{ using type = typename Ptr::difference_type; };

template <typename Ptr>
using pointer_difference_type_t =
    typename pointer_difference_type<Ptr>::type;

template <typename Base, typename T>
struct rebind;

template <template <typename, typename...> typename Template,
    typename NewType, typename OldType, typename... Args>
struct rebind<Template<OldType, Args...>, NewType> {
    using type = Template<NewType, Args...>;
};

template <typename Ptr, typename T, typename = void>
struct try_rebind { using type = typename rebind<Ptr, T>::type; };

template <typename Ptr, typename T>
struct try_rebind<Ptr, T,
    std::void_t<typename Ptr::template rebind<T>>> {
    using type = typename Ptr::template rebind<T>;
};

template <typename Ptr, typename = void>
struct pointer_element {};

template <typename Ptr>
struct pointer_element<Ptr, std::enable_if_t<
    std::is_same_v<void, std::void_t<typename Ptr::element_type>>
>> { using type = typename Ptr::element_type; };

template <template <typename, typename...> typename Template,
    typename T, typename... Args>
struct pointer_element<Template<T, Args...>, void>
{ using type = T; };

template <typename Ptr, typename = void>
struct pointer_traits_impl {};

template <typename Ptr>
struct pointer_traits_impl<Ptr,
    std::void_t<typename pointer_element<Ptr>::type>> {
    using pointer = Ptr;
    using element_type = typename pointer_element<Ptr>::type;
    using difference_type = pointer_difference_type_t<Ptr>;

    template <typename U>
    using rebind = typename try_rebind<Ptr, U>::type;

    static pointer pointer_to(element_type& ref)
    { return Ptr::pointer_to(ref); }
};

template <typename T>
struct pointer_traits_impl<T*, void> {
    using pointer = T*;
    using element_type = T;
    using difference_type = std::ptrdiff_t;

    template <typename U>
    using rebind = U*;

    static pointer pointer_to(element_type& ref)
    { return std::addressof(ref); }
};

} // namespace __helpers

template <typename Ptr>
struct pointer_traits : public __helpers::pointer_traits_impl<Ptr> {};

namespace __helpers {

template <typename Alloc, typename = void>
struct allocator_pointer
{ using type = typename Alloc::value_type*; };

template <typename Alloc>
struct allocator_pointer<Alloc,
    std::void_t<typename Alloc::pointer>>
{ using type = typename Alloc::pointer; };

template <typename Alloc>
using allocator_pointer_t =
    typename allocator_pointer<Alloc>::type;


template <typename Alloc, typename Pointer, typename = void>
struct allocator_const_pointer {
    using type = typename std::pointer_traits<Pointer>::template
        rebind<const typename Alloc::value_type>;
};

template <typename Alloc, typename Pointer>
struct allocator_const_pointer<Alloc, Pointer,
    std::void_t<typename Alloc::const_pointer>>
{ using type = typename Alloc::const_pointer; };

template <typename Alloc, typename Pointer>
using allocator_const_pointer_t =
    typename allocator_const_pointer<Alloc, Pointer>::type;


template <typename Alloc, typename Pointer, typename = void>
struct allocator_void_pointer {
    using type = typename std::pointer_traits<Pointer>::template
        rebind<void>;
};

template <typename Alloc, typename Pointer>
struct allocator_void_pointer<Alloc, Pointer,
    std::void_t<typename Alloc::void_pointer>>
{ using type = typename Alloc::void_pointer; };

template <typename Alloc, typename Pointer>
using allocator_void_pointer_t =
    typename allocator_void_pointer<Alloc, Pointer>::type;


template <typename Alloc, typename Pointer, typename = void>
struct allocator_const_void_pointer {
    using type = typename std::pointer_traits<Pointer>::template
        rebind<const void>;
};

template <typename Alloc, typename Pointer>
struct allocator_const_void_pointer<Alloc, Pointer,
    std::void_t<typename Alloc::const_void_pointer>>
{ using type = typename Alloc::const_void_pointer; };

template <typename Alloc, typename Pointer>
using allocator_const_void_pointer_t =
    typename allocator_const_void_pointer<Alloc, Pointer>::type;


template <typename Alloc, typename = void>
struct allocator_difference_type
{ using type = std::ptrdiff_t; };
template <typename Alloc>
struct allocator_difference_type<Alloc,
    std::void_t<typename Alloc::difference_type>>
{ using type = typename Alloc::difference_type; };
template <typename Alloc>
using allocator_difference_type_t =
    typename allocator_difference_type<Alloc>::type;

template <typename Alloc, typename = void>
struct allocator_size_type
{ using type = std::size_t; };
template <typename Alloc>
struct allocator_size_type<Alloc,
    std::void_t<typename Alloc::size_type>>
{ using type = typename Alloc::size_type; };
template <typename Alloc>
using allocator_size_type_t =
    typename allocator_size_type<Alloc>::type;

template <typename Alloc, typename = void>
struct allocator_prop_copy
{ using type = std::false_type; };
template <typename Alloc>
struct allocator_prop_copy<Alloc,
    std::void_t<typename Alloc::propagate_on_container_copy_assignment>>
{ using type = typename Alloc::propagate_on_container_copy_assignment; };
template <typename Alloc>
using allocator_prop_copy_t =
    typename allocator_prop_copy<Alloc>::type;

template <typename Alloc, typename = void>
struct allocator_prop_move
{ using type = std::false_type; };
template <typename Alloc>
struct allocator_prop_move<Alloc,
    std::void_t<typename Alloc::propagate_on_container_move_assignment>>
{ using type = typename Alloc::propagate_on_container_move_assignment; };
template <typename Alloc>
using allocator_prop_move_t =
    typename allocator_prop_move<Alloc>::type;

template <typename Alloc, typename = void>
struct allocator_prop_swap
{ using type = std::false_type; };
template <typename Alloc>
struct allocator_prop_swap<Alloc,
    std::void_t<typename Alloc::propagate_on_container_swap>>
{ using type = typename Alloc::propagate_on_container_swap; };
template <typename Alloc>
using allocator_prop_swap_t =
    typename allocator_prop_swap<Alloc>::type;

template <typename Alloc, typename = void>
struct is_always_equal
{ using type = std::false_type; };
template <typename Alloc>
struct is_always_equal<Alloc,
    std::void_t<typename Alloc::is_always_equal>>
{ using type = typename Alloc::is_always_equal; };
template <typename Alloc>
using is_always_equal_t =
    typename is_always_equal<Alloc>::type;

template <typename Alloc, typename = void>
struct allocator_select_on_copy {
    static constexpr Alloc get(const Alloc& alloc)
    { return alloc; }
};

template <typename Alloc>
struct allocator_select_on_copy<Alloc, std::enable_if_t<
    std::is_same_v<void, std::void_t<decltype(
        std::declval<Alloc>().select_on_container_copy_construction()
    )>> >> {
    static constexpr Alloc get(const Alloc& alloc)
    { return alloc.select_on_container_copy_construction(); }
};

template <typename Allocator, typename T, typename = void>
struct allocator_rebind_type {
    using type = typename rebind<Allocator, T>::type;
};

template <typename Allocator, typename T>
struct allocator_rebind_type<Allocator, T, std::void_t<
    typename Allocator::template rebind<T>::other
>> {
    using type = typename Allocator::template rebind<T>::other;
};

} // namespace __helpers

template <typename T>
struct allocator {
    using value_type = T;
    using propagate_on_container_move_assignment = std::true_type;

    constexpr allocator() noexcept = default;
    constexpr allocator(const allocator& other) noexcept = default;

    template <typename U>
    constexpr allocator(const allocator<U>&) noexcept {}

    constexpr ~allocator() = default;

    // throws std::bad_alloc
    [[nodiscard]] constexpr T* allocate(std::size_t n)
    { return static_cast<T*>(::operator new(n * sizeof(T))); }

    // TODO: check allocated size
    constexpr void deallocate(T* ptr, std::size_t)
    { ::operator delete(ptr); }
};

template <typename T1, typename T2>
constexpr bool operator==(const allocator<T1>&, const allocator<T2>&) noexcept
{ return true; }

template <typename T, typename... Args>
constexpr std::enable_if_t<std::is_same_v<T*,
    decltype(::new(std::declval<void*>()) T(std::declval<Args>()...))> , T*>
construct_at(T* p, Args&&... args)
{
    return ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
}

template <typename T>
constexpr void destroy_at(T* p)
{
    // TODO: destroy array
    p->~T();
}

template <typename Allocator>
struct allocator_traits {
    using allocator_type = Allocator;
    using value_type = typename Allocator::value_type;
    using pointer =
        __helpers::allocator_pointer_t<Allocator>;
    using const_pointer =
        __helpers::allocator_const_pointer_t<Allocator, pointer>;
    using void_pointer =
        __helpers::allocator_void_pointer_t<Allocator, pointer>;
    using const_void_pointer =
        __helpers::allocator_const_void_pointer_t<Allocator, pointer>;
    using difference_type =
        __helpers::allocator_difference_type_t<Allocator>;
    using size_type =
        __helpers::allocator_size_type_t<Allocator>;
    using propagate_on_container_copy_assignment =
        __helpers::allocator_prop_copy_t<Allocator>;
    using propagate_on_container_move_assignment =
        __helpers::allocator_prop_move_t<Allocator>;
    using propagate_on_container_swap =
        __helpers::allocator_prop_swap_t<Allocator>;
    using is_always_equal =
        __helpers::is_always_equal_t<Allocator>;

    template <typename T>
    using rebind_alloc =
        typename __helpers::allocator_rebind_type<Allocator, T>::type;

    [[nodiscard]] static constexpr pointer allocate(Allocator& alloc, size_type n)
    { return alloc.allocate(n); }
    static constexpr void deallocate(Allocator& alloc, pointer p, size_type n)
    { return alloc.deallocate(p, n); }
    template <typename T, typename... Args>
    static constexpr void construct(Allocator&, T* p, Args&&... args)
    { std::construct_at(p, std::forward<Args>(args)...); }
    template <typename T>
    static constexpr void destroy(Allocator&, T* p)
    { std::destroy_at(p); }

    static constexpr Allocator
        select_on_container_copy_construction(const Allocator& alloc)
    { return __helpers::allocator_select_on_copy<Allocator>::get(alloc); }
};

template <typename T>
struct default_delete {
    __GBLIBCPP_CONSTEXPR default_delete() noexcept = default;

    template <typename U, std::enable_if_t<std::is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR default_delete(const default_delete<U>&) noexcept {}

    __GBLIBCPP_CONSTEXPR void operator()(T* p) const
    {
        delete p;
    }
};

// TODO: weak_ptr
template <typename T>
class shared_ptr {
public:
    using element_type = std::remove_extent_t<T>;
    using pointer = element_type*; // TODO: pointer_traits
    using const_pointer = const element_type*;
    using reference = element_type&;
    using const_reference = const element_type&;

private:
    struct control_block_base {
        std::size_t ref_count;
        std::size_t weak_count;
        pointer ptr;

        constexpr control_block_base(std::size_t ref_count,
            std::size_t weak_count, pointer ptr)
            : ref_count(ref_count)
            , weak_count(weak_count)
            , ptr(ptr)
        {
        }

        virtual constexpr ~control_block_base() = default;
        virtual constexpr void do_delete() = 0;

        // template <typename U, std::enable_if_t<std::is_convertible_v<T*, U*>, bool> = true>
        // constexpr operator typename shared_ptr<U>::control_block_base*() const
        // {
        //     return this;
        // }
    };

    template <typename Deleter>
    struct control_block : public virtual control_block_base, private Deleter {
        using Base = control_block_base;

        virtual constexpr ~control_block() = default;

        constexpr control_block(std::size_t ref_count, std::size_t weak_count, pointer ptr)
            : control_block_base { ref_count, weak_count, ptr }, Deleter{} { }

        template <typename UDeleter>
        constexpr control_block(std::size_t ref_count,
            std::size_t weak_count, pointer ptr, UDeleter&& deleter)
            : control_block_base { ref_count, weak_count, ptr }
            , Deleter(std::forward<UDeleter>(deleter))
        {
        }

        virtual constexpr void do_delete() override
        {
            if (this->Base::ptr)
                this->Deleter::operator()(this->Base::ptr);
            this->Base::ptr = nullptr;
        }
    };

    control_block_base* cb {};
    pointer ptr {};

    void inc_ref()
    {
        if (cb)
            ++cb->ref_count; // TODO: lock and atomic
    }

    void dec_ref()
    {
        if (cb && --cb->ref_count == 0) {
            cb->do_delete();
            if (cb->weak_count == 0)
                delete cb;
        }
    }

private:
    template <typename Deleter>
    using rebind_allocator = typename std::allocator_traits<Deleter>::template rebind_alloc<control_block<Deleter>>;

    template <typename U>
    friend class shared_ptr;

public:
    __GBLIBCPP_CONSTEXPR shared_ptr() noexcept = default;
    __GBLIBCPP_CONSTEXPR shared_ptr(std::nullptr_t) noexcept { }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR explicit shared_ptr(U* p) // TODO: array type
        : cb(new control_block<default_delete<T>> { 1, 0, p })
        , ptr(p)
    {
    }

    template <typename U, typename Deleter, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR explicit shared_ptr(U* p, Deleter d)
        : cb(new control_block<Deleter> { 1, 0, p, d })
        , ptr(p)
    {
    }

    template <typename Deleter>
    __GBLIBCPP_CONSTEXPR explicit shared_ptr(std::nullptr_t, Deleter d)
        : cb(new control_block<Deleter> { 1, 0, nullptr, d })
    {
    }

    template <typename U, typename Deleter, typename Allocator,
        enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR explicit shared_ptr(U* p, Deleter d, Allocator alloc)
    {
        cb = std::allocator_traits<
            rebind_allocator<Deleter>>::allocate(alloc, 1);

        std::allocator_traits<
            rebind_allocator<Deleter>>::construct(alloc, cb, 1, 0, p, d);

        ptr = p;
    }

    template <typename Deleter, typename Allocator>
    __GBLIBCPP_CONSTEXPR explicit shared_ptr(std::nullptr_t, Deleter d, Allocator alloc)
    {
        cb = std::allocator_traits<
            rebind_allocator<Deleter>>::allocate(alloc, 1);

        std::allocator_traits<
            rebind_allocator<Deleter>>::construct(alloc, cb, 1, 0, nullptr, d);
    }

    __GBLIBCPP_CONSTEXPR
    shared_ptr(const shared_ptr& other) noexcept
        : cb(other.cb)
        , ptr(other.ptr)
    {
        inc_ref();
    }

    __GBLIBCPP_CONSTEXPR
    shared_ptr(shared_ptr&& other) noexcept
        : cb(std::exchange(other.cb, nullptr))
        , ptr(std::exchange(other.ptr, nullptr))
    {
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR
    shared_ptr(const shared_ptr<U>& other) noexcept
        : cb((control_block_base*)other.cb)
        , ptr((T*)other.ptr)
    {
        inc_ref();
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR
    shared_ptr(shared_ptr<U>&& other) noexcept
        : cb((control_block_base*)std::exchange(other.cb, nullptr))
        , ptr((T*)std::exchange(other.ptr, nullptr))
    {
    }

    // TODO: weak_ptr and unique_ptr

    __GBLIBCPP_CONSTEXPR
    ~shared_ptr()
    {
        dec_ref();
        cb = nullptr;
        ptr = nullptr;
    }

    __GBLIBCPP_CONSTEXPR
    shared_ptr& operator=(const shared_ptr& other) noexcept
    {
        shared_ptr { other }.swap(*this);
        return *this;
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR shared_ptr& operator=(const shared_ptr<U>& other) noexcept
    {
        shared_ptr { other }.swap(*this);
        return *this;
    }

    __GBLIBCPP_CONSTEXPR
    shared_ptr& operator=(shared_ptr&& other) noexcept
    {
        shared_ptr { move(other) }.swap(*this);
        return *this;
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR shared_ptr& operator=(shared_ptr<U>&& other) noexcept
    {
        shared_ptr { move(other) }.swap(*this);
        return *this;
    }

    __GBLIBCPP_CONSTEXPR
    element_type* get() const noexcept
    {
        return cb ? ptr : nullptr;
    }

    __GBLIBCPP_CONSTEXPR
    explicit operator bool() const noexcept
    {
        return get();
    }

    __GBLIBCPP_CONSTEXPR
    T& operator*() const noexcept { return *get(); }
    __GBLIBCPP_CONSTEXPR
    T* operator->() const noexcept { return get(); }
    __GBLIBCPP_CONSTEXPR
    element_type& operator[](std::size_t i) const noexcept { return get()[i]; }

    __GBLIBCPP_CONSTEXPR
    long use_count() const noexcept { return cb ? cb->ref_count : 0; }

    __GBLIBCPP_CONSTEXPR
    bool owner_before(const shared_ptr& other) const noexcept
    {
        return cb < other.cb;
    }

    __GBLIBCPP_CONSTEXPR
    void swap(shared_ptr& other) noexcept
    {
        std::swap(cb, other.cb);
        std::swap(ptr, other.ptr);
    }

    __GBLIBCPP_CONSTEXPR
    void reset() noexcept
    {
        shared_ptr {}.swap(*this);
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR void reset(U* p) noexcept
    {
        shared_ptr { p }.swap(*this);
    }

    template <typename U, typename Deleter, enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR void reset(U* p, Deleter d) noexcept
    {
        shared_ptr { p, d }.swap(*this);
    }

    template <typename U, typename Deleter, typename Allocator,
        enable_if_t<is_convertible_v<U*, T*>, bool> = true>
    __GBLIBCPP_CONSTEXPR void reset(U* p, Deleter d, Allocator alloc)
    {
        shared_ptr { p, d, alloc }.swap(*this);
    }
};

template <typename T, typename Deleter = std::default_delete<T>>
class unique_ptr {
public:
    using element_type = T;
    using deleter_type = Deleter;
    using pointer = element_type*;

private:
    impl::compressed_pair<pointer, deleter_type> data;

public:
    __GBLIBCPP_CONSTEXPR unique_ptr() noexcept: data{impl::default_construct_t{}} { }
    __GBLIBCPP_CONSTEXPR unique_ptr(std::nullptr_t) noexcept: unique_ptr{} { }
    __GBLIBCPP_CONSTEXPR unique_ptr(pointer p) noexcept: data{p, deleter_type{}} { }
    __GBLIBCPP_CONSTEXPR unique_ptr(pointer p, const deleter_type& d) noexcept: data{p, d} { }
    __GBLIBCPP_CONSTEXPR unique_ptr(pointer p, deleter_type&& d) noexcept: data{p, std::move(d)} { }
    __GBLIBCPP_CONSTEXPR unique_ptr(const unique_ptr&) = delete;

    __GBLIBCPP_CONSTEXPR unique_ptr(unique_ptr&& other) noexcept
        : data{std::exchange(other.data.first(), nullptr), std::move(other.data.second())} { }

    template <typename U, typename E, std::enable_if_t<
        !std::is_array_v<U> && std::is_convertible_v<U*, T*>
            && std::is_convertible_v<E, Deleter>, bool> = true>
    __GBLIBCPP_CONSTEXPR unique_ptr(unique_ptr<U, E>&& other) noexcept
        : data{std::exchange(other.data.first(), nullptr), std::move(other.data.second())} { }

    __GBLIBCPP_CONSTEXPR ~unique_ptr() { reset(); }

    __GBLIBCPP_CONSTEXPR unique_ptr& operator=(const unique_ptr&) = delete;
    __GBLIBCPP_CONSTEXPR unique_ptr& operator=(std::nullptr_t) noexcept
    {
        reset();
        return *this;
    }

    __GBLIBCPP_CONSTEXPR unique_ptr& operator=(unique_ptr&& other) noexcept
    {
        reset(other.release());
        get_deleter() = std::move(other.get_deleter());
        return *this;
    }

    template <typename U, typename E, std::enable_if_t<
        !std::is_array_v<U> && std::is_convertible_v<U*, T*>
            && std::is_assignable_v<Deleter&, E&&>, bool> = true>
    __GBLIBCPP_CONSTEXPR unique_ptr& operator=(unique_ptr<U, E>&& other) noexcept
    {
        reset(other.release());
        get_deleter() = std::move(other.get_deleter());
        return *this;
    }

    __GBLIBCPP_CONSTEXPR void swap(unique_ptr& other) noexcept
    {
        std::swap(data, other.data);
    }

    __GBLIBCPP_CONSTEXPR pointer get() const noexcept { return data.first(); }
    __GBLIBCPP_CONSTEXPR deleter_type& get_deleter() noexcept { return data.second(); }
    __GBLIBCPP_CONSTEXPR const deleter_type& get_deleter() const noexcept { return data.second(); }

    __GBLIBCPP_CONSTEXPR pointer release() noexcept
    {
        pointer ret = get();
        data.first() = nullptr;
        return ret;
    }

    __GBLIBCPP_CONSTEXPR void reset(pointer p = pointer{}) noexcept
    {
        pointer old = release();
        data.first() = p;
        if (old)
            get_deleter()(old);
    }

    __GBLIBCPP_CONSTEXPR explicit operator bool() const noexcept { return get(); }
    __GBLIBCPP_CONSTEXPR pointer operator->() const noexcept { return get(); }

    __GBLIBCPP_CONSTEXPR std::add_lvalue_reference_t<T> operator*() const
        noexcept(noexcept(*std::declval<pointer>())) { return *get(); }
};

// TODO: use only one allocation
template <typename T, typename... Args>
std::shared_ptr<T> make_shared(Args&&... args)
{
    return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T, typename... Args>
__GBLIBCPP_CONSTEXPR std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T>
__GBLIBCPP_CONSTEXPR void swap(std::shared_ptr<T>& lhs, std::shared_ptr<T>& rhs) noexcept
{
    lhs.swap(rhs);
}

template <typename T, typename D>
__GBLIBCPP_CONSTEXPR void swap(std::unique_ptr<T, D>& lhs, std::unique_ptr<T, D>& rhs) noexcept
{
    lhs.swap(rhs);
}

} // namespace std

#endif