C/C++ API Reference
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Friends | List of all members
pw::IntrusiveForwardList< T > Class Template Reference
pw_containers » Lists

Overview

template<typename T>
class pw::IntrusiveForwardList< T >

A singly-list intrusive list.

IntrusiveForwardList<T> is a handle to access and manipulate the list, and IntrusiveForwardList<T>::Item is the type from which the base class items must derive.

As a singly-linked list, the overhead required is only sizeof(T*). However, operations such as removal may require O(n) time to walk the length of the list.

This class is modeled on std::forward_list, with the following differences:

  • Since items are not allocated by this class, the following methods have no analogue:
    • std::forward_list<T>::get_allocator
    • std::forward_list<T>::emplace_after
    • std::forward_list<T>::emplace_front
    • std::forward_list<T>::resize
  • Methods corresponding to the following take initializer lists of pointer to items rather than the itenms themselves:
    • std::forward_list<T>::(constructor)
    • std::forward_list<T>::assign
    • std::forward_list<T>::insert_after
  • There are no overloads corresponding to the following methods that take r-value references.:
    • std::forward_list<T>::insert_after
    • std::forward_list<T>::push_front
    • std::forward_list<T>::splice_after
  • Since modifying the list modifies the items themselves, methods corresponding to those below only take iterators and not const_iterators:
    • std::forward_list<T>::insert_after
    • std::forward_list<T>::erase_after
    • std::forward_list<T>::splice_after
  • C++23 methods are not (yet) supported.
Template Parameters
TType of intrusive items stored in the list.

Classes

class  Item
 

Public Types

using element_type = T
 
using value_type = std::remove_cv_t< element_type >
 
using size_type = std::size_t
 
using difference_type = std::ptrdiff_t
 
using reference = value_type &
 
using const_reference = const value_type &
 
using pointer = element_type *
 
using const_pointer = const element_type *
 
using iterator = typename ::pw::containers::internal::ForwardIterator< T, ItemBase >
 
using const_iterator = typename ::pw::containers::internal::ForwardIterator< std::add_const_t< T >, const ItemBase >
 

Public Member Functions

 IntrusiveForwardList (const IntrusiveForwardList &)=delete
 
IntrusiveForwardList & operator= (const IntrusiveForwardList &)=delete
 
 IntrusiveForwardList (IntrusiveForwardList &&)=default
 
IntrusiveForwardList & operator= (IntrusiveForwardList &&)=default
 
template<typename Iterator >
 IntrusiveForwardList (Iterator first, Iterator last)
 
 IntrusiveForwardList (std::initializer_list< Item * > items)
 Constructs a list from a std::initializer_list of pointers to items.
 
template<typename Iterator >
void assign (Iterator first, Iterator last)
 
void assign (std::initializer_list< T * > items)
 
reference front ()
 Reference to the first element in the list. Undefined behavior if empty().
 
const_reference front () const
 
iterator before_begin () noexcept
 
const_iterator before_begin () const noexcept
 
const_iterator cbefore_begin () const noexcept
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
const_iterator cbegin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cend () const noexcept
 
bool empty () const noexcept
 
constexpr size_type max_size () const noexcept
 
void clear ()
 
iterator insert_after (iterator pos, T &item)
 Inserts the given item after the given position, pos.
 
template<typename Iterator >
iterator insert_after (iterator pos, Iterator first, Iterator last)
 
iterator insert_after (iterator pos, std::initializer_list< T * > items)
 
iterator erase_after (iterator pos)
 Removes the item following pos from the list. The item is not destructed.
 
iterator erase_after (iterator first, iterator last)
 Removes the range of items from first (inclusive) to last (exclusive).
 
void push_front (T &item)
 Inserts the item at the start of the list.
 
void pop_front ()
 Removes the first item in the list. The list must not be empty.
 
void swap (IntrusiveForwardList< T > &other) noexcept
 
void merge (IntrusiveForwardList< T > &other)
 
template<typename Compare >
void merge (IntrusiveForwardList< T > &other, Compare comp)
 
void splice_after (iterator pos, IntrusiveForwardList< T > &other)
 
void splice_after (iterator pos, IntrusiveForwardList< T > &other, iterator it)
 
void splice_after (iterator pos, IntrusiveForwardList< T > &other, iterator first, iterator last)
 
bool remove (const T &item)
 
template<typename UnaryPredicate >
size_type remove_if (UnaryPredicate pred)
 
void reverse ()
 
size_type unique ()
 
template<typename BinaryPredicate >
size_type unique (BinaryPredicate pred)
 
void sort ()
 
template<typename Compare >
void sort (Compare comp)
 

Friends

template<typename >
class containers::internal::LegacyIntrusiveList
 
The documentation for this class was generated from the following file: