## Class node_list

zeep::xml::node_list — implementation of basic_node_list for node objects

## Synopsis

    // In header: <zeep/xml/node.hpp>

    class node_list : public  {
    public:
      // types
      typedef basic_node_list                     ;
      typedef basic_list::iterator       ;
      typedef basic_list::const_iterator ;

      // construct/copy/destruct
      (element &);
      (element &, node_list &);
      (element &, node_list &&);
      node_list & (node_list &);
      node_list & (node_list &&) ;

      // public member functions
       (node_list &) ;
       (node_list &) ;
       (, node &);
       (, node &&);
      template<typename InputIter>
         (, , );
      template<typename InsertNodeType>
         (, );
       (, node &);
       (, node &&);
       ();
       (, );
       (node &);
       (node &&);
      template< Args> node & ();
       ();
       (node &);
       (node &&);
      template<typename ENodeType,   = >
         ();
      template<typename ENodeType,   = >
         ();
      template< Args> node & ();
       ();
       ();
       ();
       () ;
       ();
       () ;
    };

## Description

### `node_list` public construct/copy/destruct

1.     (element & e);

2.     (element & e, node_list & l);

3.     (element & e, node_list && l);

4.     node_list & (node_list & l);

5.     node_list & (node_list && l) ;

### `node_list` public member functions

1.      (node_list & l) ;

2.      (node_list & l) ;

3.      ( pos, node & e);

4.      ( pos, node && e);

5.     template<typename InputIter>
          ( pos,  first,  last);

6.     template<typename InsertNodeType>
          ( pos,
                          nodes);

7.      ( pos, node & n);

8.      ( pos, node && n);

9.      ( pos);

10.      ( first,  last);

11.      (node & e);

12.      (node && e);

13.     template< Args> node & ( args);

14.      ();

15.      (node & e);

16.      (node && e);

17.     template<typename ENodeType,   = >
           ( n);

18.     template<typename ENodeType,   = >
           ( n);

19.     template< Args> node & ( args);

20.      ();

21.      ();

22.      ();

23.      () ;

24.      ();

25.      () ;