template <typename T_slot>

struct slot_list

{

using slot_type = T_slot;

using reference = slot_type&;

using const_reference = const slot_type&;

using iterator = slot_iterator<slot_type>;

using reverse_iterator = std::reverse_iterator<iterator>;

slot_list() : sig_impl_(nullptr) {}

explicit slot_list(internal::signal_impl* sig_impl) : sig_impl_(sig_impl) {}

iterator begin() { return iterator(sig_impl_->slots_.begin()); }

iterator end() { return iterator(sig_impl_->slots_.end()); }

reverse_iterator rbegin() { return reverse_iterator(end()); }

reverse_iterator rend() { return reverse_iterator(begin()); }

reference front() { return *begin(); }

const_reference front() const { return *begin(); }

reference back() { return *(--end()); }

const_reference back() const { return *(--end()); }

iterator insert(iterator i, const slot_type& slot_)

{

return iterator(sig_impl_->insert(i.i_, slot_));

}

iterator insert(iterator i, slot_type&& slot_)

{

return iterator(sig_impl_->insert(i.i_, std::move(slot_)));

}

void push_front(const slot_type& c) { insert(begin(), c); }

void push_front(slot_type&& c) { insert(begin(), std::move(c)); }

void push_back(const slot_type& c) { insert(end(), c); }

void push_back(slot_type&& c) { insert(end(), std::move(c)); }

iterator erase(iterator i) { return iterator(sig_impl_->erase(i.i_)); }

iterator erase(iterator first_, iterator last_)

{

while (first_ != last_)

first_ = erase(first_);

return last_;

}

void pop_front() { erase(begin()); }

void pop_back()

{

auto tmp_ = end();

erase(--tmp_);

}

internal::signal_impl* sig_impl_;

};