SharedWeakCachePointer.h

#ifndef XRPL_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
#define XRPL_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
 
#include <memory>
#include <variant>
 
namespace ripple {
 
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();
 
    std::shared_ptr<T> const&
    getStrong() const;
 
    explicit
    operator bool() const noexcept;
 
    void
    reset();
 
    T*
    get() const;
 
    std::size_t
    use_count() const;
 
    bool
    expired() const;
 
    std::shared_ptr<T>
    lock() const;
 
    bool
    isStrong() const;
 
    bool
    isWeak() const;
 
    bool
    convertToStrong();
 
    bool
    convertToWeak();
 
private:
    std::variant<std::shared_ptr<T>, std::weak_ptr<T>> combo_;
};
}  // namespace ripple
#endif