#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/lambda/lambda.hpp>
#include <algorithm>
#include <iostream>
#include <vector>

using namespace boost::lambda;
using namespace boost::multi_index;
using boost::multi_index_container;

template<typename Index,typename Modifier>
void modify_range(
  Index& i,typename Index::iterator first,typename Index::iterator last,
  Modifier mod)
{
  while(first!=last)i.modify(first++,mod);
}

template<typename Index,typename Modifier>
void modify_unstable_range(
  Index& i,typename Index::iterator first,typename Index::iterator last,
  Modifier mod)
{
  typedef std::vector<typename Index::iterator> buffer_type;
  buffer_type v;
  while(first!=last)v.push_back(first++);
  
  for(typename buffer_type::iterator it=v.begin(),it_end=v.end();
      it!=it_end;i.modify(*it++,mod));
}

template<typename Container>
void dump(const Container& c)
{
  std::copy(
    c.begin(),c.end(),
    std::ostream_iterator<typename Container::value_type>(std::cout," "));
  std::cout<<std::endl;
}

struct adder
{
  adder(int n):n(n){}
  void operator()(int& x)const{x+=n;}
  
private:
  int n;
};

int main()
{
  typedef multi_index_container<
    int,
    indexed_by<
      ordered_non_unique<boost::multi_index::identity<int> >
    >
  > multi_index_type;
  
  multi_index_type m;
  for(int i=0;i<10;++i)m.insert(i);
  
  modify_range(m,m.begin(),m.end(),adder(-2));
  dump(m);

  modify_range(m,m.begin(),m.end(),boost::lambda::_1-=2);
  dump(m);

  modify_unstable_range(m,m.begin(),m.end(),adder(2));
  dump(m);

  modify_unstable_range(m,m.begin(),m.end(),boost::lambda::_1+=2);
  dump(m);
}