#include<boost/fusion/adapted.hpp>
#include<boost/fusion/algorithm.hpp>
#include<boost/fusion/iterator.hpp>
#include<boost/mpl/bool.hpp>
#include<boost/mpl/or.hpp>
#include<boost/type_traits/is_convertible.hpp>
#include<boost/type_traits/add_reference.hpp>
#include<boost/type_traits/is_reference.hpp>
#include<iostream>

class A
{
	int i;

public:
	A(int i):i(i){}
	void set(int i){this->i=i;}
	int get()const{return i;}
};
BOOST_FUSION_ADAPT_CLASS(A,(int,int,obj.get(),obj.set(val)))

struct B
{
	int i;
};
BOOST_FUSION_ADAPT_STRUCT(B,(int,i))

using namespace boost::fusion;

template<typename F>
struct FWrapper
{
	typedef int result_type;

	template<typename It>
	void impl(It it,boost::mpl::true_)const
	{
		std::cout<<"direct";
		return f(deref(it));
	}

	template<typename It>
	void impl(It it,boost::mpl::false_)const
	{
		std::cout<<"indirect";
		result_of::value_of<It>::type val=deref(it);
		f(val);
		deref(it)=val;
	}

	template<typename It>
	int operator()(int,It it)const
	{
		typedef typename result_of::deref<It>::type dt;
		typedef typename result_of::value_of<It>::type vt;
		typedef boost::mpl::or_<boost::is_reference<dt>,boost::is_convertible<dt,typename boost::add_reference<vt>::type> > c;

		impl(it,boost::mpl::bool_<c::value>());
		return 0;
	}

	F f;
};

template<typename F,typename Seq>
void
ref_for_each(Seq&seq)
{
	iter_fold(seq,0,FWrapper<F>());
}

struct F
{
	typedef void result_type;

	void operator()(int&i)const
	{
		std::cout<<" int& "<<i++<<std::endl;
	}

	void operator()(int const&i)const
	{
		std::cout<<" int const& "<<i<<std::endl;
	}
};

int main()
{
	A a(0);
	ref_for_each<F>(a);
	ref_for_each<F>(const_cast<A const&>(a));

	B b={0};
	ref_for_each<F>(b);
	ref_for_each<F>(const_cast<B const&>(b));
}