rcp/include/rcp.h

/*
 * Copyright (C) 2026 Josh Holtrop
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the “Software”), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#pragma once

#include <atomic>
#include <functional>
#include <type_traits>

/**
 * Reference-counting pointer.
 */
template <typename T>
class rcp
{
    template <typename U> friend class rcp;

private:
    T * ptr = nullptr;

public:
    rcp() = default;

    rcp(T * p) : ptr(p)
    {
        if (p)
        {
            p->rcp_inc();
        }
    }

    rcp(const rcp & other) : ptr(other.ptr)
    {
        if (ptr)
        {
            ptr->rcp_inc();
        }
    }

    rcp & operator=(const rcp & other)
    {
        if (ptr != other.ptr)
        {
            T * old_ptr = ptr;
            ptr = other.ptr;
            if (ptr)
            {
                ptr->rcp_inc();
            }
            if (old_ptr)
            {
                old_ptr->rcp_dec();
            }
        }
        return *this;
    }

    rcp(rcp && other) noexcept : ptr(other.ptr)
    {
        other.ptr = nullptr;
    }

    rcp & operator=(rcp && other) noexcept
    {
        if (this != &other)
        {
            if (ptr)
            {
                ptr->rcp_dec();
            }
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }

    ~rcp()
    {
        if (ptr)
        {
            ptr->rcp_dec();
        }
    }

    /* Upcasting constructor: allows rcp<Derived> -> rcp<Base> */
    template <typename U>
    rcp(const rcp<U> & other) : ptr(static_cast<T *>(other.ptr))
    {
        static_assert(std::is_base_of<T, U>::value, "rcp: implicit cast must be an upcast");
        if (ptr)
        {
            ptr->rcp_inc();
        }
    }

    template <typename U>
    rcp(rcp<U> && other) : ptr(static_cast<T *>(other.ptr))
    {
        static_assert(std::is_base_of<T, U>::value, "rcp: implicit cast must be an upcast");
        other.ptr = nullptr;
    }

    int use_count() const
    {
        return ptr ? ptr->rcp_count() : 0;
    }

    void swap(rcp & other) noexcept
    {
        T * tmp = ptr;
        ptr = other.ptr;
        other.ptr = tmp;
    }

    void reset()
    {
        if (ptr)
        {
            ptr->rcp_dec();
            ptr = nullptr;
        }
    }

    T * get_raw() const
    {
        return ptr;
    }

    T * operator->() const
    {
        return ptr;
    }

    T & operator*() const
    {
        return *ptr;
    }

    explicit operator bool() const
    {
        return ptr != nullptr;
    }

    template <typename U>
    bool operator==(const rcp<U> & other) const
    {
        return static_cast<const void *>(ptr) == static_cast<const void *>(other.ptr);
    }

    template <typename U>
    bool operator!=(const rcp<U> & other) const
    {
        return static_cast<const void *>(ptr) != static_cast<const void *>(other.ptr);
    }

    template <typename U>
    bool operator<(const rcp<U> & other) const
    {
        return std::less<const void *>()(
            static_cast<const void *>(ptr),
            static_cast<const void *>(other.ptr));
    }

    template <typename U>
    bool operator<=(const rcp<U> & other) const
    {
        return !std::less<const void *>()(
            static_cast<const void *>(other.ptr),
            static_cast<const void *>(ptr));
    }

    template <typename U>
    bool operator>(const rcp<U> & other) const
    {
        return std::less<const void *>()(
            static_cast<const void *>(other.ptr),
            static_cast<const void *>(ptr));
    }

    template <typename U>
    bool operator>=(const rcp<U> & other) const
    {
        return !std::less<const void *>()(
            static_cast<const void *>(ptr),
            static_cast<const void *>(other.ptr));
    }

    bool operator==(std::nullptr_t) const
    {
        return ptr == nullptr;
    }

    bool operator!=(std::nullptr_t) const
    {
        return ptr != nullptr;
    }

    template <typename... Args>
    static rcp create(Args&&... args)
    {
        return T::create(std::forward<Args>(args)...);
    }

    template <typename V, typename W>
    friend rcp<V> rcp_dynamic_cast(rcp<W> && other);
};

namespace std
{
    template <typename T>
    struct hash<rcp<T>>
    {
        size_t operator()(const rcp<T> & p) const noexcept
        {
            return hash<const void *>()(static_cast<const void *>(p.get_raw()));
        }
    };
}

template <typename T, typename U>
rcp<T> rcp_dynamic_cast(const rcp<U> & other)
{
    return rcp<T>(dynamic_cast<T *>(other.get_raw()));
}

template <typename T, typename U>
rcp<T> rcp_dynamic_cast(rcp<U> && other)
{
    T * p = dynamic_cast<T *>(other.ptr);
    if (p)
    {
        other.ptr = nullptr;
        rcp<T> result;
        result.ptr = p;
        return result;
    }
    return rcp<T>();
}

#define rcp_managed_root(classname) \
    public: \
        void rcp_inc() const \
        { \
            ref_count.fetch_add(1, std::memory_order_relaxed); \
        } \
        void rcp_dec() const \
        { \
            if (ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) \
            { \
                delete this; \
            } \
        } \
        int rcp_count() const \
        { \
            return ref_count.load(std::memory_order_relaxed); \
        } \
    private: \
        mutable std::atomic<int> ref_count{0}; \
    rcp_managed(classname)

#define rcp_managed(classname) \
    public: \
        rcp<classname> get_rcp() \
        { \
            return rcp<classname>(this); \
        } \
        template <typename... Args> \
        static rcp<classname> create(Args&&... args) \
        { \
            return (new classname(std::forward<Args>(args)...))->get_rcp(); \
        } \
    private: