#pragma once

template<typename T>
void
unordered_erase (std::vector<T> &vec, typename std::vector<T>::iterator pos)
{
  vec.at (vec.end () - pos) = vec.back ();
  vec.pop_back ();
}

template<typename T>
void
unordered_erase (std::vector<T> &vec, typename std::vector<T>::size_type pos)
{
  unordered_erase (vec, vec.begin () + pos);
}

template<typename T>
void
unordered_erase (std::vector<T> &vec, typename std::vector<T>::const_reference element)
{
  unordered_erase (vec, &element - &vec.front ());
}

template<typename T>
struct unordered_vector
{
  typedef std::vector<T>                                vector_type;

  typedef typename vector_type::value_type              value_type;
  typedef typename vector_type::pointer                 pointer;
  typedef typename vector_type::const_pointer           const_pointer;
  typedef typename vector_type::reference               reference;
  typedef typename vector_type::const_reference         const_reference;
  typedef typename vector_type::iterator                iterator;
  typedef typename vector_type::const_iterator          const_iterator;
  typedef typename vector_type::reverse_iterator        reverse_iterator;
  typedef typename vector_type::const_reverse_iterator  const_reverse_iterator;
  typedef typename vector_type::size_type               size_type;
  typedef typename vector_type::difference_type         difference_type;

        iterator begin ()       { return items.begin (); }
        iterator end   ()       { return items.end   (); }
  const_iterator begin () const { return items.begin (); }
  const_iterator end   () const { return items.end   (); }

  void push_back (value_type const &x) { return items.push_back (x); }

        reference front ()       { return items.front (); }
  const_reference front () const { return items.front (); }
        reference back  ()       { return items.back  (); }
  const_reference back  () const { return items.back  (); }

        reference at (size_type n)       { return items.at (n); }
  const_reference at (size_type n) const { return items.at (n); }

  void pop_back () { return items.pop_back (); }

  size_type size () const { return items.size (); }
  bool empty () const { return items.empty (); }

  void erase (iterator pos)        { return unordered_erase (items, pos); }
  void erase (size_type pos)       { return unordered_erase (items, pos); }
  void erase (const_reference elt) { return unordered_erase (items, elt); }

  vector_type items;
};