safe_pointers.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte.
 *
 * StormByte original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte source in this repository.
 * They do not cover other StormByte modules or any third-party material
 * shipped with this repository (including everything under thirdparty/),
 * which remains under its own license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * StormByte 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with StormByte. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/type_traits.hxx>
#include <StormByte/visibility.h>
 
#include <compare>
#include <cstddef>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
 
namespace StormByte {
    template<class T>
    class Shared;
 
    template<class T>
    class Unique;
 
    template<class T>
    class Weak;
 
    namespace Heap {
        STORMBYTE_PUBLIC void* Allocate(std::size_t bytes);
 
        STORMBYTE_PUBLIC void Free(void* pointer) noexcept;
 
        struct ObjectDeleter {
            template<class U>
            void operator()(U* pointer) const noexcept {
                pointer->~U();
                Free(pointer);
            }
        };
 
        template<typename T>
        struct Allocator {
            using value_type = T;   
 
            constexpr Allocator() noexcept = default;
 
            template<typename U>
            constexpr Allocator(const Allocator<U>&) noexcept {}
 
            [[nodiscard]] T* allocate(std::size_t count) {
                return static_cast<T*>(Allocate(count * sizeof(T)));
            }
 
            void deallocate(T* pointer, std::size_t) noexcept {
                Free(pointer);
            }
 
            template<typename U>
            constexpr bool operator==(const Allocator<U>&) const noexcept {
                return true;
            }
        };
 
        template<class T, class... Args>
        Shared<T> MakeShared(Args&&... args);
 
        template<class T, class... Args>
        Unique<T> MakeUnique(Args&&... args);
    }
 
    template<class T>
    class Shared {
        public:
            using element_type = T; 
            using weak_type = Weak<T>;  
 
            Shared() noexcept = default;
 
            Shared(std::nullptr_t) noexcept {}
 
            template<class U>
            requires Type::SameAs<U, T> || Type::DerivedFrom<U, T>
            Shared(const Shared<U>& other) noexcept: m_ptr(other.m_ptr) {}
 
            template<class U>
            requires Type::SameAs<U, T> || Type::DerivedFrom<U, T>
            Shared(Shared<U>&& other) noexcept: m_ptr(std::move(other.m_ptr)) {}
 
            Shared(const Shared&) noexcept = default;
 
            Shared(Shared&&) noexcept = default;
 
            explicit Shared(const Weak<T>& weak);
 
            Shared& operator=(const Shared&) noexcept = default;
 
            Shared& operator=(Shared&&) noexcept = default;
 
            ~Shared() = default;
 
            T* get() const noexcept {
                return m_ptr.get();
            }
 
            T& operator*() const {
                return *m_ptr;
            }
 
            T* operator->() const noexcept {
                return m_ptr.get();
            }
 
            explicit operator bool() const noexcept {
                return static_cast<bool>(m_ptr);
            }
 
            operator std::shared_ptr<T>() const noexcept {
                return m_ptr;
            }
 
            long use_count() const noexcept {
                return m_ptr.use_count();
            }
 
            void reset() noexcept {
                m_ptr.reset();
            }
 
            void swap(Shared& other) noexcept {
                m_ptr.swap(other.m_ptr);
            }
 
            template<class U>
            bool owner_before(const Shared<U>& other) const noexcept {
                return m_ptr.owner_before(other.m_ptr);
            }
 
            template<class U>
            bool owner_before(const Weak<U>& other) const noexcept;
 
            template<class Target, class... Args>
            requires Type::SameAs<Target, T> || Type::DerivedFrom<Target, T>
            static Shared<T> MakePointer(Args&&... args) {
                return Heap::MakeShared<Target>(std::forward<Args>(args)...);
            }
 
            friend bool operator==(const Shared& lhs, std::nullptr_t) noexcept {
                return !lhs.m_ptr;
            }
 
            friend bool operator!=(const Shared& lhs, std::nullptr_t) noexcept {
                return static_cast<bool>(lhs.m_ptr);
            }
 
            friend bool operator==(std::nullptr_t, const Shared& rhs) noexcept {
                return !rhs.m_ptr;
            }
 
            friend bool operator!=(std::nullptr_t, const Shared& rhs) noexcept {
                return static_cast<bool>(rhs.m_ptr);
            }
 
            friend bool operator==(const Shared& lhs, const Shared& rhs) noexcept {
                return lhs.get() == rhs.get();
            }
 
            friend auto operator<=>(const Shared& lhs, const Shared& rhs) noexcept {
                return std::compare_three_way{}(lhs.get(), rhs.get());
            }
 
            friend void swap(Shared& left, Shared& right) noexcept {
                left.swap(right);
            }
 
        private:
            explicit Shared(std::shared_ptr<T> pointer) noexcept: m_ptr(std::move(pointer)) {}
 
            struct Adopt {
                explicit constexpr Adopt() noexcept = default;
            };
 
            explicit Shared(Adopt, T* object): m_ptr(object, Heap::ObjectDeleter{}, Heap::Allocator<T>{}) {}
 
            template<class U>
            friend class Shared;
 
            template<class U>
            friend class Weak;
 
            template<class U, class... Args>
            friend Shared<U> Heap::MakeShared(Args&&...);
 
            template<class X, class Y>
            friend Shared<X> StaticPointerCast(const Shared<Y>&) noexcept;
 
            template<class X, class Y>
            friend Shared<X> DynamicPointerCast(const Shared<Y>&) noexcept;
 
            template<class X, class Y>
            friend Shared<X> ConstPointerCast(const Shared<Y>&) noexcept;
 
            template<class X, class Y>
            friend Shared<X> ReinterpretPointerCast(const Shared<Y>&) noexcept;
 
            std::shared_ptr<T> m_ptr;   
    };
 
    template<class T>
    class Unique {
        public:
            using element_type = T; 
            using pointer = T*; 
            using deleter_type = Heap::ObjectDeleter;   
 
            Unique() noexcept = default;
 
            Unique(std::nullptr_t) noexcept {}
 
            template<class U>
            requires Type::SameAs<U, T> || (Type::DerivedFrom<U, T> && std::has_virtual_destructor_v<T>)
            Unique(Unique<U>&& other) noexcept: m_ptr(std::move(other.m_ptr)) {}
 
            Unique(const Unique&) = delete;
 
            Unique(Unique&&) noexcept = default;
 
            Unique& operator=(const Unique&) = delete;
 
            Unique& operator=(Unique&&) noexcept = default;
 
            ~Unique() = default;
 
            T* get() const noexcept {
                return m_ptr.get();
            }
 
            T& operator*() const {
                return *m_ptr;
            }
 
            T* operator->() const noexcept {
                return m_ptr.get();
            }
 
            explicit operator bool() const noexcept {
                return static_cast<bool>(m_ptr);
            }
 
            operator std::unique_ptr<T, Heap::ObjectDeleter>() && noexcept {
                return std::move(m_ptr);
            }
 
            deleter_type& get_deleter() noexcept {
                return m_ptr.get_deleter();
            }
 
            const deleter_type& get_deleter() const noexcept {
                return m_ptr.get_deleter();
            }
 
            void reset() noexcept {
                m_ptr.reset();
            }
 
            void swap(Unique& other) noexcept {
                m_ptr.swap(other.m_ptr);
            }
 
            template<class Target, class... Args>
            requires Type::SameAs<Target, T> || (Type::DerivedFrom<Target, T> && std::has_virtual_destructor_v<T>)
            static Unique<T> MakePointer(Args&&... args) {
                return Heap::MakeUnique<Target>(std::forward<Args>(args)...);
            }
 
            friend bool operator==(const Unique& lhs, std::nullptr_t) noexcept {
                return !lhs.m_ptr;
            }
 
            friend bool operator!=(const Unique& lhs, std::nullptr_t) noexcept {
                return static_cast<bool>(lhs.m_ptr);
            }
 
            friend bool operator==(std::nullptr_t, const Unique& rhs) noexcept {
                return !rhs.m_ptr;
            }
 
            friend bool operator!=(std::nullptr_t, const Unique& rhs) noexcept {
                return static_cast<bool>(rhs.m_ptr);
            }
 
            friend bool operator==(const Unique& lhs, const Unique& rhs) noexcept {
                return lhs.get() == rhs.get();
            }
 
            friend auto operator<=>(const Unique& lhs, const Unique& rhs) noexcept {
                return std::compare_three_way{}(lhs.get(), rhs.get());
            }
 
            friend void swap(Unique& left, Unique& right) noexcept {
                left.swap(right);
            }
 
        private:
            struct Adopt {
                explicit constexpr Adopt() noexcept = default;
            };
 
            explicit Unique(Adopt, T* object): m_ptr(object) {}
 
            template<class U>
            friend class Unique;
 
            template<class U, class... Args>
            friend Unique<U> Heap::MakeUnique(Args&&...);
 
            std::unique_ptr<T, Heap::ObjectDeleter> m_ptr;  
    };
 
    template<class T>
    class Weak {
        public:
            using element_type = T; 
 
            Weak() noexcept = default;
 
            Weak(std::nullptr_t) noexcept {}
 
            template<class U>
            requires Type::SameAs<U, T> || Type::DerivedFrom<U, T>
            Weak(const Shared<U>& owner) noexcept: m_weak(owner.m_ptr) {}
 
            Weak(const Weak&) noexcept = default;
 
            Weak(Weak&&) noexcept = default;
 
            Weak& operator=(const Weak&) noexcept = default;
 
            Weak& operator=(Weak&&) noexcept = default;
 
            ~Weak() = default;
 
            Shared<T> lock() const noexcept {
                return Shared<T>(m_weak.lock());
            }
 
            bool expired() const noexcept {
                return m_weak.expired();
            }
 
            long use_count() const noexcept {
                return m_weak.use_count();
            }
 
            void reset() noexcept {
                m_weak.reset();
            }
 
            void swap(Weak& other) noexcept {
                m_weak.swap(other.m_weak);
            }
 
            template<class U>
            bool owner_before(const Weak<U>& other) const noexcept {
                return m_weak.owner_before(other.m_weak);
            }
 
            template<class U>
            bool owner_before(const Shared<U>& other) const noexcept {
                return m_weak.owner_before(other.m_ptr);
            }
 
            friend void swap(Weak& left, Weak& right) noexcept {
                left.swap(right);
            }
 
        private:
            template<class U>
            friend class Weak;
 
            template<class U>
            friend class Shared;
 
            std::weak_ptr<T> m_weak;    
    };
 
    template<class T, class U>
    Shared<T> StaticPointerCast(const Shared<U>& from) noexcept {
        return Shared<T>(std::static_pointer_cast<T>(std::shared_ptr<U>(from)));
    }
 
    template<class T, class U>
    Shared<T> DynamicPointerCast(const Shared<U>& from) noexcept {
        return Shared<T>(std::dynamic_pointer_cast<T>(std::shared_ptr<U>(from)));
    }
 
    template<class T, class U>
    Shared<T> ConstPointerCast(const Shared<U>& from) noexcept {
        return Shared<T>(std::const_pointer_cast<T>(std::shared_ptr<U>(from)));
    }
 
    template<class T, class U>
    Shared<T> ReinterpretPointerCast(const Shared<U>& from) noexcept {
        return Shared<T>(std::reinterpret_pointer_cast<T>(std::shared_ptr<U>(from)));
    }
 
    template<class T>
    Shared<T>::Shared(const Weak<T>& weak): m_ptr(weak.m_weak) {}
 
    template<class T>
    template<class U>
    bool Shared<T>::owner_before(const Weak<U>& other) const noexcept {
        return m_ptr.owner_before(other.m_weak);
    }
}
 
 
template<class T>
struct std::hash<StormByte::Shared<T>> {
    std::size_t operator()(const StormByte::Shared<T>& value) const noexcept {
        return std::hash<T*>{}(value.get());
    }
};
 
template<class T>
struct std::hash<StormByte::Unique<T>> {
    std::size_t operator()(const StormByte::Unique<T>& value) const noexcept {
        return std::hash<T*>{}(value.get());
    }
};
 
#include <StormByte/safe_pointers.txx>