#ifndef _INIT_ITERATOR_GUARD
#define _INIT_ITERATOR_GUARD

#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/call_traits.hpp>
#include <boost/iterator_adaptors.hpp>

template <class T>
class init_iterator_base
{
public:
  init_iterator_base()
  {
  }

  init_iterator_base(std::vector<T> const& a_rhs)
    : values(new std::vector<T>(a_rhs))
    , current(values->begin())
  {
  }

  bool operator==(const init_iterator_base& a_rhs) const
  {
    const bool am_at_end(at_end());
	bool rhs_at_end;
    if (am_at_end || (rhs_at_end = a_rhs.at_end()))
      return am_at_end && rhs_at_end;
    return current == a_rhs.current;
  }

  bool at_end() const
  {
    return values.get() == 0 || current == values->end();
  }

  void operator++()
  {
    ++current;
  }

  const T& operator*() const
  {
    return *current;
  }

private:
  boost::shared_ptr<std::vector<T> > values;
  std::vector<T>::const_iterator current;
};

template <class T>
struct init_iterator_generator
{
  typedef boost::iterator_adaptor<
    init_iterator_base<T>, 
    boost::default_iterator_policies,
    const T,
    const T&,
    const T*,
    std::forward_iterator_tag,
    ptrdiff_t> type;
};

template <class T>
class initializer
{
public:
  typedef init_iterator_generator<T>::type iterator;
  initializer(boost::call_traits<T>::param_type a_param)
  {
    values.push_back(a_param);
  }

  iterator operator()() const
  {
    return iterator(init_iterator_base<T>(values));
  }

  initializer& operator()(boost::call_traits<T>::param_type a_param)
  {
    values.push_back(a_param);
    return *this;
  }

private:
  std::vector<T> values;
};

template <class T>
init_iterator_generator<T>::type make_init_iterator()
{
  return init_iterator_generator<T>::type(init_iterator_base<T>());
}

template <class T>
initializer<T> make_init_iterator(
  boost::call_traits<T>::param_type a_param)
{
  return initializer<T>(a_param);
}

#endif