SharedWeakCachePointer.h

#pragma once
 
#include <concepts>
#include <cstddef>
#include <memory>
#include <variant>
 
namespace xrpl {

 
template <class T>
class SharedWeakCachePointer
{
public:
    SharedWeakCachePointer() = default;
 
    SharedWeakCachePointer(SharedWeakCachePointer const& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakCachePointer(std::shared_ptr<TT> const& rhs);
 
    SharedWeakCachePointer(SharedWeakCachePointer&& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakCachePointer(std::shared_ptr<TT>&& rhs);
 
    SharedWeakCachePointer&
    operator=(SharedWeakCachePointer const& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakCachePointer&
    operator=(std::shared_ptr<TT> const& rhs);
 
    template <class TT>
        requires std::convertible_to<TT*, T*>
    SharedWeakCachePointer&
    operator=(std::shared_ptr<TT>&& rhs);
 
    ~SharedWeakCachePointer();

    [[nodiscard]] std::shared_ptr<T> const&
    getStrong() const;

    explicit
    operator bool() const noexcept;

    void
    reset();

    [[nodiscard]] T*
    get() const;

    [[nodiscard]] std::size_t
    useCount() const;

    [[nodiscard]] bool
    expired() const;

    [[nodiscard]] std::shared_ptr<T>
    lock() const;

    [[nodiscard]] bool
    isStrong() const;

    [[nodiscard]] bool
    isWeak() const;

    bool
    convertToStrong();

    bool
    convertToWeak();
 
private:
    std::variant<std::shared_ptr<T>, std::weak_ptr<T>> combo_;
};
}  // namespace xrpl