Class template slist_member

Class template slist_member_hook

boost::intrusive::slist_member_hook

Synopsis

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

template<class... Options> 
class slist_member_hook : public make_slist_member_hook::type< O1, O2, O3 > {
public:
  // construct/copy/destruct
  slist_member_hook();
  slist_member_hook(const slist_member_hook &);
  slist_member_hook & operator=(const slist_member_hook &);
  ~slist_member_hook();

  // public member functions
  void swap_nodes(slist_member_hook &);
  bool is_linked() const;
  void unlink();
};

Description

Put a public data member slist_member_hook in order to store objects of this class in an list. slist_member_hook holds the data necessary for maintaining the list and provides an appropriate value_traits class for list.

The hook admits the following options: void_pointer<> and link_mode<>.

link_mode<> will specify the linking mode of the hook (normal_link, auto_unlink or safe_link).

void_pointer<> is the pointer type that will be used internally in the hook and the container configured to use this hook.

`slist_member_hook` public construct/copy/destruct

```
slist_member_hook();
```
Effects: If link_mode is auto_unlink or safe_link initializes the node to an unlinked state.

Throws: Nothing.
```
slist_member_hook(const slist_member_hook &);
```
Effects: If link_mode is auto_unlink or safe_link initializes the node to an unlinked state. The argument is ignored.

Throws: Nothing.

Rationale: Providing a copy-constructor makes classes using the hook STL-compliant without forcing the user to do some additional work. swap can be used to emulate move-semantics.
```
slist_member_hook & operator=(const slist_member_hook &);
```
Effects: Empty function. The argument is ignored.

Throws: Nothing.

Rationale: Providing an assignment operator makes classes using the hook STL-compliant without forcing the user to do some additional work. swap can be used to emulate move-semantics.
```
~slist_member_hook();
```
Effects: If link_mode is normal_link, the destructor does nothing (ie. no code is generated). If link_mode is safe_link and the object is stored in an slist an assertion is raised. If link_mode is auto_unlink and is_linked() is true, the node is unlinked.

Throws: Nothing.

`slist_member_hook` public member functions

```
void swap_nodes(slist_member_hook & other);
```
Effects: Swapping two nodes swaps the position of the elements related to those nodes in one or two containers. That is, if the node this is part of the element e1, the node x is part of the element e2 and both elements are included in the containers s1 and s2, then after the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 at the position of e1. If one element is not in a container, then after the swap-operation the other element is not in a container. Iterators to e1 and e2 related to those nodes are invalidated.

Complexity: Constant

Throws: Nothing.
```
bool is_linked() const;
```
Precondition: link_mode must be safe_link or auto_unlink.

Returns: true, if the node belongs to a container, false otherwise. This function can be used to test whether slist::iterator_to will return a valid iterator.

Note: If this member is called when the value is inserted in a slist with the option linear<true>, this function will return "false" for the last element, as it is not linked to anything (the next element is null), so use with care.

Complexity: Constant
```
void unlink();
```
Effects: Removes the node if it's inserted in a container. This function is only allowed if link_mode is auto_unlink.

Throws: Nothing.