pointers.h

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//2
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
#ifndef FENNEC_MEMORY_POINTERS_H
#define FENNEC_MEMORY_POINTERS_H
 
#include <fennec/lang/type_traits.h>
#include <fennec/lang/utility.h>
 
namespace fennec
{
 
template<typename TypeT>
struct default_delete
{
    constexpr default_delete() noexcept = default;
 
    template<class ConvT> requires requires { is_convertible<ConvT*, TypeT*>{}.value == true; }
    constexpr default_delete(const default_delete<ConvT>&) noexcept {}
 
    constexpr void operator()(TypeT* ptr) const noexcept {
        static_assert(not is_void_v<TypeT>, "cannot delete a pointer to an incomplete type");
        static_assert(is_complete_v<TypeT>, "cannot delete a pointer to an incomplete type");
        delete ptr;
    }
};
 
// Overload for Arrays
template<typename TypeT>
struct default_delete<TypeT[]>
{
    constexpr default_delete() noexcept = default;
 
    template<class ConvT> requires requires { is_convertible_v<ConvT(*)[], TypeT(*)[]> == true; }
    constexpr default_delete(const default_delete<ConvT(*)[]>&) noexcept {}
 
    template<class ArrT> requires requires { is_convertible_v<ArrT(*)[], TypeT(*)[]> == true; }
    constexpr void operator()(TypeT* ptr) const noexcept {
        static_assert(not is_void_v<TypeT>, "cannot delete a pointer to an incomplete type");
        static_assert(is_complete_v<TypeT>, "cannot delete a pointer to an incomplete type");
        delete[] ptr;
    }
};
 
 
 
template<typename TypeT, class DeleteT = default_delete<TypeT>>
class unique_ptr
{
public:
    using element_t = TypeT;
 
    using pointer_t = element_t*;
 
    using const_pointer_t = const element_t*;
 
    using delete_t = DeleteT;
 
    constexpr unique_ptr() : unique_ptr(nullptr) {}
 
    constexpr unique_ptr(nullptr_t) noexcept : unique_ptr(nullptr, delete_t()) {}
 
    explicit constexpr unique_ptr(pointer_t ptr, const delete_t& del = delete_t())
        : _delete(del)
        , _handle(ptr) {
    }
 
    constexpr unique_ptr(unique_ptr&& other)
        : _handle(other._handle) {
        other._handle = nullptr;
    }
 
    // Delete copy constructor
    constexpr unique_ptr(const unique_ptr&) = delete;
 
    constexpr ~unique_ptr() {
        reset();
    }
 
    constexpr unique_ptr& operator=(const unique_ptr&) = delete;
 
    constexpr unique_ptr& operator=(unique_ptr&& r) noexcept {
        _delete = r._delete;
        _handle = r._handle;
        r._handle = nullptr;
        return *this;
    }
 
    void reset(pointer_t ptr) {
        if(_handle) {
            _delete(_handle);
            _handle = ptr;
        }
    }
 
    void reset(nullptr_t = nullptr) {
        if(_handle) {
            _delete(_handle);
            _handle = nullptr;
        }
    }
 
    pointer_t release() {
        pointer_t retval = _handle;
        _handle = nullptr;
        return retval;
    }
 
    pointer_t get() {
        return _handle;
    }
 
    bool empty() {
        return _handle == nullptr;
    }
 
    pointer_t operator->() {
        return _handle;
    }
 
    const_pointer_t operator->() const {
        return _handle;
    }
 
    operator bool() const {
        return _handle != nullptr;
    }
 
 
private:
    delete_t  _delete;
    pointer_t _handle;
};
 
template<typename TypeT, typename...ArgsT>
unique_ptr<TypeT> make_unique(ArgsT&&...args) {
    return unique_ptr<TypeT>(new TypeT(fennec::forward<ArgsT>(args)...));
}
 
}
 
#endif // FENNEC_MEMORY_POINTERS_H