LLVM: llvm::simple_ilist< T, Options > Class Template Reference (original) (raw)

A simple intrusive list implementation. More...

#include "[llvm/ADT/simple_ilist.h](simple%5F%5Filist%5F8h%5Fsource.html)"

Public Types
using	value_type = typename OptionsT::value_type
using	pointer = typename OptionsT::pointer
using	reference = typename OptionsT::reference
using	const_pointer = typename OptionsT::const_pointer
using	const_reference = typename OptionsT::const_reference
using	iterator = ilist_select_iterator_type<OptionsT, false, false>
using	const_iterator = ilist_select_iterator_type<OptionsT, false, true>
using	reverse_iterator = ilist_select_iterator_type<OptionsT, true, false>
using	const_reverse_iterator
using	size_type = size_t
using	difference_type = ptrdiff_t

Public Member Functions
	simple_ilist ()=default
	~simple_ilist ()=default
	simple_ilist (const simple_ilist &)=delete
simple_ilist &	operator= (const simple_ilist &)=delete
	simple_ilist (simple_ilist &&X)
simple_ilist &	operator= (simple_ilist &&X)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
bool	empty () const
	Check if the list is empty in constant time.
size_type	size () const
	Calculate the size of the list in linear time.
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
void	push_front (reference Node)
	Insert a node at the front; never copies.
void	push_back (reference Node)
	Insert a node at the back; never copies.
void	pop_front ()
	Remove the node at the front; never deletes.
void	pop_back ()
	Remove the node at the back; never deletes.
void	swap (simple_ilist &X)
	Swap with another list in place using std::swap.
iterator	insert (iterator I, reference Node)
	Insert a node by reference; never copies.
template
void	insert (iterator I, Iterator First, Iterator Last)
	Insert a range of nodes; never copies.
template<class Cloner, class Disposer>
void	cloneFrom (const simple_ilist &L2, Cloner clone, Disposer dispose)
	Clone another list.
void	remove (reference N)
	Remove a node by reference; never deletes.
template
void	removeAndDispose (reference N, Disposer dispose)
	Remove a node by reference and dispose of it.
iterator	erase (iterator I)
	Remove a node by iterator; never deletes.
iterator	erase (iterator First, iterator Last)
	Remove a range of nodes; never deletes.
template
iterator	eraseAndDispose (iterator I, Disposer dispose)
	Remove a node by iterator and dispose of it.
template
iterator	eraseAndDispose (iterator First, iterator Last, Disposer dispose)
	Remove a range of nodes and dispose of them.
void	clear ()
	Clear the list; never deletes.
template
void	clearAndDispose (Disposer dispose)
	Clear the list and dispose of the nodes.
void	splice (iterator I, simple_ilist &L2)
	Splice in another list.
void	splice (iterator I, simple_ilist &L2, iterator Node)
	Splice in a node from another list.
void	splice (iterator I, simple_ilist &, iterator First, iterator Last)
	Splice in a range of nodes from another list.
void	merge (simple_ilist &RHS)
	Merge in another list.
template
void	merge (simple_ilist &RHS, Compare comp)
void	sort ()
	Sort the list.
template
void	sort (Compare comp)

template<typename T, class... Options>
class llvm::simple_ilist< T, Options >

A simple intrusive list implementation.

This is a simple intrusive list for a T that inherits from [ilist_node<T>](classllvm%5F1%5F1ilist%5F%5Fnode.html). The list never takes ownership of anything inserted in it.

Unlike iplist and ilist, simple_ilist never deletes values, and has no callback traits.

The API for adding nodes include push_front(), push_back(), and insert(). These all take values by reference (not by pointer), except for the range version of insert().

There are three sets of API for discarding nodes from the list: remove(), which takes a reference to the node to remove, erase(), which takes an iterator or iterator range and returns the next one, and clear(), which empties out the container. All three are constant time operations. None of these deletes any nodes; in particular, if there is a single node in the list, then these have identical semantics:

L.remove(L.front());
L.erase(L.begin());
L.clear();

As a convenience for callers, there are parallel APIs that take a Disposer (such as std::default_delete<T>): removeAndDispose(), eraseAndDispose(), and clearAndDispose(). These have different names because the extra semantic is otherwise non-obvious. They are equivalent to calling std::for_each() on the range to be discarded.

The currently available Options customize the nodes in the list. The same options must be specified in the ilist_node instantiation for compatibility (although the order is irrelevant).

Use ilist_tag to designate which ilist_node for a given T this list should use. This is useful if a type T is part of multiple, independent lists simultaneously.
Use ilist_sentinel_tracking to always (or never) track whether a node is a sentinel. Specifying true enables the ilist_node::isSentinel() API. Unlike ilist_node::isKnownSentinel(), which is only appropriate for assertions, ilist_node::isSentinel() is appropriate for real logic.

Here are examples of Options usage:

simple_ilist<T> gives the defaults.
[simple_ilist<T,ilist_sentinel_tracking<true>>](classllvm%5F1%5F1simple%5F%5Filist.html) enables the ilist_node::isSentinel() API.
[simple_ilist](classllvm%5F1%5F1simple%5F%5Filist.html "A simple intrusive list implementation.")<T,ilist_tag,ilist_sentinel_tracking> specifies a tag of A and that tracking should be off (even when LLVM_ENABLE_ABI_BREAKING_CHECKS are enabled).
[simple_ilist](classllvm%5F1%5F1simple%5F%5Filist.html "A simple intrusive list implementation.")<T,ilist_sentinel_tracking,ilist_tag> is equivalent to the last.

See is_valid_option for steps on adding a new option.

Definition at line 78 of file simple_ilist.h.