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 {
    namespace Safe {
        template<class T>
        class STORMBYTE_PUBLIC_TYPE Shared;
 
        template<class T>
        class STORMBYTE_PUBLIC_TYPE Unique;
 
        template<class T>
        class STORMBYTE_PUBLIC_TYPE Weak;
 
        namespace Heap {
            STORMBYTE_PUBLIC void* Allocate(std::size_t bytes);
 
            STORMBYTE_PUBLIC void Free(void* pointer) noexcept;
 
            struct STORMBYTE_PUBLIC_TYPE ObjectDeleter {
                template<class U>
                void operator()(U* pointer) const noexcept {
                    pointer->~U();
                    Free(pointer);
                }
            };
 
            template<typename T>
            struct STORMBYTE_PUBLIC_TYPE 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 STORMBYTE_PUBLIC_TYPE 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 STORMBYTE_PUBLIC_TYPE 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 STORMBYTE_PUBLIC_TYPE 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::Safe::Shared<T>> {
    std::size_t operator()(const StormByte::Safe::Shared<T>& value) const noexcept {
        return std::hash<T*>{}(value.get());
    }
};
 
template<class T>
struct std::hash<StormByte::Safe::Unique<T>> {
    std::size_t operator()(const StormByte::Safe::Unique<T>& value) const noexcept {
        return std::hash<T*>{}(value.get());
    }
};
 
#include <StormByte/safe/pointers.txx>