mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-04 19:25:51 +00:00
1d42c4f6de
Per XLS-0095, we are taking steps to rename ripple(d) to xrpl(d). This change specifically removes all copyright notices referencing Ripple, XRPLF, and certain affiliated contributors upon mutual agreement, so the notice in the LICENSE.md file applies throughout. Copyright notices referencing external contributions remain as-is. Duplicate verbiage is also removed.
117 lines
3.0 KiB
C++
117 lines
3.0 KiB
C++
#ifndef XRPL_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
|
|
#define XRPL_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
|
|
|
|
#include <memory>
|
|
#include <variant>
|
|
|
|
namespace ripple {
|
|
|
|
/** A combination of a std::shared_ptr and a std::weak_pointer.
|
|
|
|
|
|
This class is a wrapper to a `std::variant<std::shared_ptr,std::weak_ptr>`
|
|
This class is useful for storing intrusive pointers in tagged caches using less
|
|
memory than storing both pointers directly.
|
|
*/
|
|
|
|
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();
|
|
|
|
/** Return a strong pointer if this is already a strong pointer (i.e. don't
|
|
lock the weak pointer. Use the `lock` method if that's what's needed)
|
|
*/
|
|
std::shared_ptr<T> const&
|
|
getStrong() const;
|
|
|
|
/** Return true if this is a strong pointer and the strong pointer is
|
|
seated.
|
|
*/
|
|
explicit
|
|
operator bool() const noexcept;
|
|
|
|
/** Set the pointer to null, decrement the appropriate ref count, and run
|
|
the appropriate release action.
|
|
*/
|
|
void
|
|
reset();
|
|
|
|
/** If this is a strong pointer, return the raw pointer. Otherwise return
|
|
null.
|
|
*/
|
|
T*
|
|
get() const;
|
|
|
|
/** If this is a strong pointer, return the strong count. Otherwise return 0
|
|
*/
|
|
std::size_t
|
|
use_count() const;
|
|
|
|
/** Return true if there is a non-zero strong count. */
|
|
bool
|
|
expired() const;
|
|
|
|
/** If this is a strong pointer, return the strong pointer. Otherwise
|
|
attempt to lock the weak pointer.
|
|
*/
|
|
std::shared_ptr<T>
|
|
lock() const;
|
|
|
|
/** Return true is this represents a strong pointer. */
|
|
bool
|
|
isStrong() const;
|
|
|
|
/** Return true is this represents a weak pointer. */
|
|
bool
|
|
isWeak() const;
|
|
|
|
/** If this is a weak pointer, attempt to convert it to a strong pointer.
|
|
|
|
@return true if successfully converted to a strong pointer (or was
|
|
already a strong pointer). Otherwise false.
|
|
*/
|
|
bool
|
|
convertToStrong();
|
|
|
|
/** If this is a strong pointer, attempt to convert it to a weak pointer.
|
|
|
|
@return false if the pointer is null. Otherwise return true.
|
|
*/
|
|
bool
|
|
convertToWeak();
|
|
|
|
private:
|
|
std::variant<std::shared_ptr<T>, std::weak_ptr<T>> combo_;
|
|
};
|
|
} // namespace ripple
|
|
#endif
|