| Home | Libraries | People | FAQ | More

## Class template linear_slist_algorithms

boost::intrusive::linear_slist_algorithms

## Synopsis

    // In header: <boost/intrusive/linear_slist_algorithms.hpp>

    template<typename NodeTraits>
    class linear_slist_algorithms {
    public:
      // types
      typedef NodeTraits::node node;
      typedef NodeTraits::node_ptr       node_ptr;
      typedef NodeTraits::const_node_ptr const_node_ptr;
      typedef NodeTraits                 node_traits;

      // public static functions
      static void init(node_ptr);
      static bool unique(const_node_ptr);
      static bool inited(const_node_ptr);
      static void unlink_after(node_ptr);
      static void unlink_after(node_ptr, node_ptr);
      static void link_after(node_ptr, node_ptr);
      static void transfer_after(node_ptr, node_ptr, node_ptr);
      static void init_header(node_ptr);
      static node_ptr get_previous_node(node_ptr, node_ptr);
      static std::size_t count(const_node_ptr);
      static void swap_trailing_nodes(node_ptr, node_ptr);
      static node_ptr reverse(node_ptr);
      static std::pair< node_ptr, node_ptr >
      move_first_n_backwards(node_ptr, std::size_t);
      static std::pair< node_ptr, node_ptr >
      move_first_n_forward(node_ptr, std::size_t);
    };

## Description

linear_slist_algorithms provides basic algorithms to manipulate nodes forming a linear singly linked list.

linear_slist_algorithms is configured with a NodeTraits class, which encapsulates the information about the node to be manipulated. NodeTraits must support the following interface:

Typedefs:

`node`: The type of the node that forms the linear list

`node_ptr`: A pointer to a node

`const_node_ptr`: A pointer to a const node

Static functions:

`static node_ptr get_next(const_node_ptr n);`

`static void set_next(node_ptr n, node_ptr next);` @ : public detail::common_slist_algorithms<NodeTraits>

### `linear_slist_algorithms` public types

1. typedef NodeTraits::node node;

   @ typedef detail::common_slist_algorithms<NodeTraits> base_t;

### `linear_slist_algorithms` public static functions

1.     static void init(node_ptr this_node);

   Effects: Constructs an non-used list element, putting the next pointer to null: `NodeTraits::get_next(this_node) == 0`

   `Complexity: Constant`

   `Throws: Nothing.`

2.     static bool unique(const_node_ptr this_node);

   Requires: this_node must be in a circular list or be an empty circular list.

   Effects: Returns true is "this_node" is the only node of a circular list: or it's a not inserted node: `return !NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node`

   Complexity: Constant

   Throws: Nothing.

3.     static bool inited(const_node_ptr this_node);

   Effects: Returns true is "this_node" has the same state as if it was inited using "init(node_ptr)"

   Complexity: Constant

   Throws: Nothing.

4.     static void unlink_after(node_ptr prev_node);

   Requires: prev_node must be in a circular list or be an empty circular list.

   Effects: Unlinks the next node of prev_node from the circular list.

   Complexity: Constant

   Throws: Nothing.

5.     static void unlink_after(node_ptr prev_node, node_ptr last_node);

   Requires: prev_node and last_node must be in a circular list or be an empty circular list.

   Effects: Unlinks the range (prev_node, last_node) from the linear list.

   Complexity: Constant

   Throws: Nothing.

6.     static void link_after(node_ptr prev_node, node_ptr this_node);

   Requires: prev_node must be a node of a linear list.

   Effects: Links this_node after prev_node in the linear list.

   Complexity: Constant

   Throws: Nothing.

7.     static void transfer_after(node_ptr p, node_ptr b, node_ptr e);

   Requires: b and e must be nodes of the same linear list or an empty range. and p must be a node of a different linear list.

   Effects: Removes the nodes from (b, e] range from their linear list and inserts them after p in p's linear list.

   Complexity: Constant

   Throws: Nothing.

8.     static void init_header(node_ptr this_node);

   Effects: Constructs an empty list, making this_node the only node of the circular list: `NodeTraits::get_next(this_node) == this_node`.

   Complexity: Constant

   Throws: Nothing.

9.     static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node);

   Requires: this_node and prev_init_node must be in the same linear list.

   Effects: Returns the previous node of this_node in the linear list starting. the search from prev_init_node. The first node checked for equality is NodeTraits::get_next(prev_init_node).

   Complexity: Linear to the number of elements between prev_init_node and this_node.

   Throws: Nothing.

10.     static std::size_t count(const_node_ptr this_node);

    Requires: this_node must be in a linear list or be an empty linear list.

    Effects: Returns the number of nodes in a linear list. If the linear list is empty, returns 1.

    Complexity: Linear

    Throws: Nothing.

11.     static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node);

    Requires: this_node and other_node must be nodes inserted in linear lists or be empty linear lists.

    Effects: Moves all the nodes previously chained after this_node after other_node and vice-versa.

    Complexity: Constant

    Throws: Nothing.

12.     static node_ptr reverse(node_ptr p);

    Effects: Reverses the order of elements in the list.

    Returns: The new first node of the list.

    Throws: Nothing.

    Complexity: This function is linear to the contained elements.

13.     static std::pair< node_ptr, node_ptr >
        move_first_n_backwards(node_ptr p, std::size_t n);

    Effects: Moves the first n nodes starting at p to the end of the list.

    Returns: A pair containing the new first and last node of the list or if there has been any movement, a null pair if n leads to no movement.

    Throws: Nothing.

    Complexity: Linear to the number of elements plus the number moved positions.

14.     static std::pair< node_ptr, node_ptr >
        move_first_n_forward(node_ptr p, std::size_t n);

    Effects: Moves the first n nodes starting at p to the beginning of the list.

    Returns: A pair containing the new first and last node of the list or if there has been any movement, a null pair if n leads to no movement.

    Throws: Nothing.

    Complexity: Linear to the number of elements plus the number moved positions.