uniqueptr.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cassert>
#include <type_traits>
#include <utility>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> class UniquePtr {
        public:
                // All UniquePtr instantiations are friends of each other so the
                // upcast/downcast helpers can reach the private _ptr across
                // type boundaries.
                template <typename U> friend class UniquePtr;
 
                UniquePtr() = default;
 
                UniquePtr(std::nullptr_t) noexcept {}
 
                UniquePtr(const UniquePtr &) = delete;
 
                UniquePtr &operator=(const UniquePtr &) = delete;
 
                UniquePtr(UniquePtr &&o) noexcept : _ptr(o._ptr) { o._ptr = nullptr; }
 
                template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U> && !std::is_same_v<T, U>>>
                UniquePtr(UniquePtr<U> &&o) noexcept : _ptr(o._ptr) {
                        o._ptr = nullptr;
                }
 
                ~UniquePtr() { clear(); }
 
                UniquePtr &operator=(UniquePtr &&o) noexcept {
                        if (&o == this) return *this;
                        clear();
                        _ptr = o._ptr;
                        o._ptr = nullptr;
                        return *this;
                }
 
                template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U> && !std::is_same_v<T, U>>>
                UniquePtr &operator=(UniquePtr<U> &&o) noexcept {
                        clear();
                        _ptr = o._ptr;
                        o._ptr = nullptr;
                        return *this;
                }
 
                template <typename... Args> static UniquePtr create(Args &&...args) {
                        UniquePtr up;
                        up._ptr = new T(std::forward<Args>(args)...);
                        return up;
                }
 
                static UniquePtr takeOwnership(T *obj) {
                        UniquePtr up;
                        up._ptr = obj;
                        return up;
                }
 
                void clear() {
                        if (_ptr == nullptr) return;
                        delete _ptr;
                        _ptr = nullptr;
                        return;
                }
 
                T *release() {
                        T *p = _ptr;
                        _ptr = nullptr;
                        return p;
                }
 
                void reset(T *obj = nullptr) {
                        delete _ptr;
                        _ptr = obj;
                        return;
                }
 
                void swap(UniquePtr &other) noexcept { std::swap(_ptr, other._ptr); }
 
                bool isNull() const { return _ptr == nullptr; }
 
                bool isValid() const { return _ptr != nullptr; }
 
                explicit operator bool() const { return _ptr != nullptr; }
 
                bool operator==(const UniquePtr &other) const { return _ptr == other._ptr; }
                bool operator!=(const UniquePtr &other) const { return _ptr != other._ptr; }
                bool operator==(std::nullptr_t) const { return _ptr == nullptr; }
                bool operator!=(std::nullptr_t) const { return _ptr != nullptr; }
 
                T *ptr() const {
                        assert(_ptr != nullptr);
                        return _ptr;
                }
 
                T *get() const { return _ptr; }
 
                T *operator->() const { return ptr(); }
                T &operator*() const { return *ptr(); }
 
        private:
                T *_ptr = nullptr;
};
 
template <typename T> void swap(UniquePtr<T> &a, UniquePtr<T> &b) noexcept {
        a.swap(b);
}
 
template <typename T> class UniquePtr<T[]> {
        public:
                UniquePtr() = default;
 
                UniquePtr(std::nullptr_t) noexcept {}
 
                UniquePtr(const UniquePtr &) = delete;
 
                UniquePtr &operator=(const UniquePtr &) = delete;
 
                UniquePtr(UniquePtr &&o) noexcept : _ptr(o._ptr) { o._ptr = nullptr; }
 
                ~UniquePtr() { clear(); }
 
                UniquePtr &operator=(UniquePtr &&o) noexcept {
                        if (&o == this) return *this;
                        clear();
                        _ptr = o._ptr;
                        o._ptr = nullptr;
                        return *this;
                }
 
                static UniquePtr createArray(size_t n) {
                        UniquePtr up;
                        up._ptr = new T[n];
                        return up;
                }
 
                static UniquePtr createArrayValueInit(size_t n) {
                        UniquePtr up;
                        up._ptr = new T[n]();
                        return up;
                }
 
                static UniquePtr takeOwnership(T *obj) {
                        UniquePtr up;
                        up._ptr = obj;
                        return up;
                }
 
                void clear() {
                        if (_ptr == nullptr) return;
                        delete[] _ptr;
                        _ptr = nullptr;
                        return;
                }
 
                T *release() {
                        T *p = _ptr;
                        _ptr = nullptr;
                        return p;
                }
 
                void reset(T *obj = nullptr) {
                        delete[] _ptr;
                        _ptr = obj;
                        return;
                }
 
                void swap(UniquePtr &other) noexcept { std::swap(_ptr, other._ptr); }
 
                bool isNull() const { return _ptr == nullptr; }
 
                bool isValid() const { return _ptr != nullptr; }
 
                explicit operator bool() const { return _ptr != nullptr; }
 
                bool operator==(const UniquePtr &other) const { return _ptr == other._ptr; }
                bool operator!=(const UniquePtr &other) const { return _ptr != other._ptr; }
                bool operator==(std::nullptr_t) const { return _ptr == nullptr; }
                bool operator!=(std::nullptr_t) const { return _ptr != nullptr; }
 
                T *ptr() const {
                        assert(_ptr != nullptr);
                        return _ptr;
                }
 
                T *get() const { return _ptr; }
 
                T &operator[](size_t i) const {
                        assert(_ptr != nullptr);
                        return _ptr[i];
                }
 
        private:
                T *_ptr = nullptr;
};
 
template <typename T> void swap(UniquePtr<T[]> &a, UniquePtr<T[]> &b) noexcept {
        a.swap(b);
}
 
template <typename Derived, typename Base> UniquePtr<Derived> uniquePointerCast(UniquePtr<Base> &&up) {
        static_assert(std::is_base_of_v<Base, Derived>, "Derived must publicly derive from Base");
        if (up.isNull()) return UniquePtr<Derived>();
        Derived *d = dynamic_cast<Derived *>(up.ptr());
        if (d == nullptr) return UniquePtr<Derived>();
        up.release();
        return UniquePtr<Derived>::takeOwnership(d);
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE