: public std::iterator<std::output_iterator_tag, void, void, void, void> {

public:

typedef behavior_stack::element_type element_type;

explicit behavior_stack_help_iterator(behavior_stack& st) : m_stack(&st) { }

behavior_stack_help_iterator& operator=(element_type&& rval) {

m_stack->m_erased_elements.emplace_back(std::move(rval.first));

return *this;

}

behavior_stack_help_iterator& operator*() { return *this; }

behavior_stack_help_iterator& operator++() { return *this; }

behavior_stack_help_iterator operator++(int) { return *this; }

private:

behavior_stack* m_stack;

if (m_elements.empty()) {

// nothing to do

}

else if (m_elements.back().second.valid() == false) {

m_erased_elements.emplace_back(std::move(m_elements.back().first));

m_elements.pop_back();

}

else {

auto rlast = m_elements.rend();

auto ri = std::find_if(m_elements.rbegin(), rlast,

[](element_type& e) {

return e.second.valid() == false;

});

if (ri != rlast) {

m_erased_elements.emplace_back(std::move(ri->first));

auto i = ri.base();

--i; // adjust 'normal' iterator to point to the correct element

m_elements.erase(i);

}

}

auto last = m_elements.end();

auto i = std::find_if(m_elements.begin(), last, [=](element_type& e) {

return e.second == response_id;

});

if (i != last) {

m_erased_elements.emplace_back(std::move(i->first));

m_elements.erase(i);

}

if (m_elements.empty() == false) {

std::move(m_elements.begin(), m_elements.end(),

behavior_stack_help_iterator{*this});

m_elements.clear();

}