## 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 zeep::xml::basic_node_list< node > {
    public:
      // types
      typedef basic_node_list                     basic_list;
      typedef typename basic_list::iterator       iterator;
      typedef typename basic_list::const_iterator const_iterator;

      // construct/copy/destruct
      node_list(element &);
      node_list(element &, const node_list &);
      node_list(element &, node_list &&);
      node_list & operator=(const node_list &);
      node_list & operator=(node_list &&) noexcept;

      // public member functions
      bool operator==(const node_list &) const;
      bool operator!=(const node_list &) const;
      void insert(const_iterator, const node &);
      void insert(const_iterator, node &&);
      template<typename InputIter>
        iterator insert(const_iterator, InputIter, InputIter);
      template<typename InsertNodeType>
        iterator insert(const_iterator, std::initializer_list< InsertNodeType >);
      iterator emplace(const_iterator, const node &);
      iterator emplace(const_iterator, node &&);
      iterator erase(const_iterator);
      iterator erase(iterator, iterator);
      void push_front(const node &);
      void push_front(node &&);
      template<typename... Args> node & emplace_front(Args &&...);
      void pop_front();
      void push_back(const node &);
      void push_back(node &&);
      template<typename ENodeType, std::enable_if_t< std::is_base_of_v< node, ENodeType >, int >  = 0>
        ENodeType & emplace_back(const ENodeType &);
      template<typename ENodeType, std::enable_if_t< std::is_base_of_v< node, ENodeType >, int >  = 0>
        ENodeType & emplace_back(ENodeType &&);
      template<typename... Args> node & emplace_back(Args &&...);
      void pop_back();
      void clear();
      iterator begin();
      const_iterator begin();
      iterator end();
      const_iterator end();
    };

## Description

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

1.     node_list(element & e);

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

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

4.     node_list & operator=(const node_list & l);

5.     node_list & operator=(node_list && l) noexcept;

### `node_list` public member functions

1.     bool operator==(const node_list & l) const;

2.     bool operator!=(const node_list & l) const;

3.     void insert(const_iterator pos, const node & e);

4.     void insert(const_iterator pos, node && e);

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

6.     template<typename InsertNodeType>
         iterator insert(const_iterator pos,
                         std::initializer_list< InsertNodeType > nodes);

7.     iterator emplace(const_iterator pos, const node & n);

8.     iterator emplace(const_iterator pos, node && n);

9.     iterator erase(const_iterator pos);

10.     iterator erase(iterator first, iterator last);

11.     void push_front(const node & e);

12.     void push_front(node && e);

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

14.     void pop_front();

15.     void push_back(const node & e);

16.     void push_back(node && e);

17.     template<typename ENodeType, std::enable_if_t< std::is_base_of_v< node, ENodeType >, int >  = 0>
          ENodeType & emplace_back(const ENodeType & n);

18.     template<typename ENodeType, std::enable_if_t< std::is_base_of_v< node, ENodeType >, int >  = 0>
          ENodeType & emplace_back(ENodeType && n);

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

20.     void pop_back();

21.     void clear();

22.     iterator begin();

23.     const_iterator begin();

24.     iterator end();

25.     const_iterator end();