.. _aterm_list.h: mcrl2/atermpp/aterm_list.h =============================================================================== Include file: .. code-block:: c++ #include "mcrl2/atermpp/aterm_list.h" Classes ------- * :cpp:class:`std::hash< atermpp::term_list< Term > >` * :cpp:class:`atermpp::term_list` Typedefs ------------------------------------------------------------------------------- .. cpp:type:: atermpp::aterm_list typedef for :cpp:type:`term_list\< aterm >` A term_list with elements of type aterm. Functions ------------------------------------------------------------------------------- .. cpp:function:: std::set atermpp::as_set(const atermpp::term_list< T > &x) Converts the given term list to a set. .. cpp:function:: std::vector atermpp::as_vector(const atermpp::term_list< T > &x) Converts the given term list to a vector. .. cpp:function:: std::conditional::value,term_list,term_list >::type atermpp::operator+(const term_list< Term1 > &l, const term_list< Term2 > &m) Returns the concatenation of two lists with convertible element types. The type of the result is either the type of l, if the elements of m can be converted implicitly to the type of the elements of l. Otherwise if the elements of l can be converted implicitly to the type of the elements of m, the result type is that or m. **Parameters:** * **l** A list. * **m** A list. The complexity of this operator is linear in the length of l. **Returns:** The concatenation of the lists l followed by m. .. cpp:function:: term_list atermpp::push_back(const term_list< Term > &l, const Term &el) Appends a new element at the end of the list. Note that the complexity of this function is O(n), with n the number of elements in the list!!! **Parameters:** * **l** The list to which the term is appended. * **el** A term. **Returns:** The list l with elem appended at the end. .. cpp:function:: term_list atermpp::reverse(const term_list< Term > &l) Returns the list with the elements in reversed order. **Parameters:** * **l** A list. This operator is linear in the size of the list. **Returns:** The reversed list. .. cpp:function:: term_list atermpp::sort_list(const term_list< Term > &l, const std::function< bool(const Term &, const Term &)> &ordering=[](const Term &t1, const Term &t2){ return t1< t2;}) Returns the list with the elements sorted according to the <-operator on the addresses of terms. **Parameters:** * **l** A list. * **ordering** An total orderings relation on Term, by default the ordering relation on Terms. This operator has complexity nlog n where n is the size of the list. **Returns:** The sorted list. Functions ------------------------------------------------------------------------------- .. cpp:function:: void std::swap(atermpp::term_list< T > &t1, atermpp::term_list< T > &t2) noexcept Swaps two term_lists. This operation is more efficient than exchanging terms by an assignment, as swapping does not require to change the protection of terms. **Parameters:** * **t1** The first term * **t2** The second term