Ring buffer container of unique_ptr's of T, which can be accessed by a key. More...
#include <mapped_ring_buffer.hpp>
Public Types | |
| using | ElemAllocTraits = allocator::AllocRebind< T, Alloc > |
| using | ElemAlloc = typename ElemAllocTraits::allocator_type |
| using | ElemDeleter = allocator::Deleter< ElemAlloc, T > |
| using | ElemUniquePtr = std::unique_ptr< T, ElemDeleter > |
Public Member Functions | |
| MappedRingBuffer (size_t size, std::shared_ptr< Alloc > allocator=nullptr) | |
| Constructor. More... | |
| virtual | ~MappedRingBuffer () |
| void | get_copy_at_key (uint64_t key, ElemUniquePtr &value) |
| Return a copy of the value stored in the ring buffer at the given key. More... | |
| void | get_ownership_at_key (uint64_t key, ElemUniquePtr &value) |
| Return ownership of the value stored in the ring buffer, leaving a copy. More... | |
| void | pop_at_key (uint64_t key, ElemUniquePtr &value) |
| Return ownership of the value stored in the ring buffer at the given key. More... | |
| bool | push_and_replace (uint64_t key, ElemUniquePtr &value) |
| Insert a key-value pair, displacing an existing pair if necessary. More... | |
| bool | push_and_replace (uint64_t key, ElemUniquePtr &&value) |
| bool | has_key (uint64_t key) |
| Return true if the key is found in the ring buffer, otherwise false. More... | |
Detailed Description
template<typename T, typename Alloc = std::allocator<void>>
class rclcpp::mapped_ring_buffer::MappedRingBuffer< T, Alloc >
Ring buffer container of unique_ptr's of T, which can be accessed by a key.
T must be a CopyConstructable and CopyAssignable. This class can be used in a container by using the base class MappedRingBufferBase. This class must have a positive, non-zero size. This class cannot be resized nor can it reserve additional space after construction. This class is not CopyConstructable nor CopyAssignable.
The key's are not guaranteed to be unique because push_and_replace does not check for colliding keys. It is up to the user to only use unique keys. A side effect of this is that when get_copy_at_key or pop_at_key are called, they return the first encountered instance of the key. But iteration does not begin with the ring buffer's head, and therefore there is no guarantee on which value is returned if a key is used multiple times.
Member Typedef Documentation
§ ElemAllocTraits
| using rclcpp::mapped_ring_buffer::MappedRingBuffer< T, Alloc >::ElemAllocTraits = allocator::AllocRebind<T, Alloc> |
§ ElemAlloc
| using rclcpp::mapped_ring_buffer::MappedRingBuffer< T, Alloc >::ElemAlloc = typename ElemAllocTraits::allocator_type |
§ ElemDeleter
| using rclcpp::mapped_ring_buffer::MappedRingBuffer< T, Alloc >::ElemDeleter = allocator::Deleter<ElemAlloc, T> |
§ ElemUniquePtr
| using rclcpp::mapped_ring_buffer::MappedRingBuffer< T, Alloc >::ElemUniquePtr = std::unique_ptr<T, ElemDeleter> |
Constructor & Destructor Documentation
§ MappedRingBuffer()
|
inlineexplicit |
Constructor.
The constructor will allocate memory while reserving space.
- Parameters
-
size size of the ring buffer; must be positive and non-zero. allocator optional custom allocator
§ ~MappedRingBuffer()
|
inlinevirtual |
Member Function Documentation
§ get_copy_at_key()
|
inline |
Return a copy of the value stored in the ring buffer at the given key.
The key is matched if an element in the ring buffer has a matching key. This method will allocate in order to return a copy.
The key is not guaranteed to be unique, see the class docs for more.
The contents of value before the method is called are discarded.
- Parameters
-
key the key associated with the stored value value if the key is found, the value is stored in this parameter
§ get_ownership_at_key()
|
inline |
Return ownership of the value stored in the ring buffer, leaving a copy.
The key is matched if an element in the ring bufer has a matching key. This method will allocate in order to store a copy.
The key is not guaranteed to be unique, see the class docs for more.
The ownership of the currently stored object is returned, but a copy is made and stored in its place. This means that multiple calls to this function for a particular element will result in returning the copied and stored object not the original. This also means that later calls to pop_at_key will not return the originally stored object, since it was returned by the first call to this method.
The contents of value before the method is called are discarded.
- Parameters
-
key the key associated with the stored value value if the key is found, the value is stored in this parameter
§ pop_at_key()
|
inline |
Return ownership of the value stored in the ring buffer at the given key.
The key is matched if an element in the ring buffer has a matching key.
The key is not guaranteed to be unique, see the class docs for more.
The contents of value before the method is called are discarded.
- Parameters
-
key the key associated with the stored value value if the key is found, the value is stored in this parameter
§ push_and_replace() [1/2]
|
inline |
Insert a key-value pair, displacing an existing pair if necessary.
The key's uniqueness is not checked on insertion. It is up to the user to ensure the key is unique. This method should not allocate memory.
After insertion, if a pair was replaced, then value will contain ownership of that displaced value. Otherwise it will be a nullptr.
- Parameters
-
key the key associated with the value to be stored value the value to store, and optionally the value displaced
§ push_and_replace() [2/2]
|
inline |
§ has_key()
|
inline |
Return true if the key is found in the ring buffer, otherwise false.
The documentation for this class was generated from the following file:
- include/rclcpp/mapped_ring_buffer.hpp
