#include <boost/type_traits.hpp>
#include <boost/pending/ct_if.hpp>
#include <boost/detail/iterator.hpp>
#include <boost/iterator_adaptors.hpp>

namespace boost {

  //======================================================

  template <typename A, typename B>
  struct cons {
    typedef A first_type;
    typedef B second_type;
  };
  struct nil_type { };

  template <typename List>
  struct make_traits {
    typedef typename List::first_type Head;
    typedef typename List::second_type Rest;
    typedef typename Head::generator Gen;
    typedef typename Head::type Type;
    
    typedef typename make_traits<Rest>::type RestTraits;
    typedef typename Gen::template trait<Type, RestTraits> type;
  };

  struct empty_traits { };

  template <> struct make_traits<nil_type> {
    typedef empty_traits type;
  };

  //======================================================

#define BOOST_MAKE_TRAIT(NAME, TYPENAME) \
  struct make_##NAME { \
    template <typename T, typename Base> struct trait : public Base { \
      typedef T TYPENAME; \
    }; \
  }; \
  template <typename T>  \
  struct NAME { \
    typedef make_##NAME generator; \
    typedef T type; \
  }

  BOOST_MAKE_TRAIT(Value, value_type);
  BOOST_MAKE_TRAIT(Reference, reference);
  BOOST_MAKE_TRAIT(Pointer, pointer);
  BOOST_MAKE_TRAIT(Distance, difference_type);
  BOOST_MAKE_TRAIT(Category, iterator_category);

  struct default_argument;

  struct make_default {
    template <typename T, typename Base> struct trait {
      typedef T difference_type;
      typedef T pointer;
      typedef T reference;
      typedef T value_type;
      typedef T iterator_category;
    };
  };

  struct default_argument {
    typedef make_default generator;
    typedef default_argument type;
  };

  template <typename T> struct is_default { enum { value = false }; };  
  struct is_default<default_argument> { enum { value = true }; };

  template <typename Base, typename Policies,
    typename Arg1 = default_argument,
    typename Arg2 = default_argument,
    typename Arg3 = default_argument,
    typename Arg4 = default_argument,
    typename Arg5 = default_argument>
  class iterator_adaptor_generator
  {
    typedef cons<Arg1, cons<Arg2, cons<Arg3, cons<Arg4, cons<Arg5, 
      nil_type> > > > > ArgList;
    typedef make_traits<ArgList>::type traits;
    typedef typename traits::value_type Value;
    typedef typename traits::difference_type Distance_;
    typedef typename traits::reference Reference_;
    typedef typename traits::pointer Pointer_;
    typedef typename traits::iterator_category Category_;
    
    typedef boost::detail::iterator_traits<Base> base_traits;
    typedef boost::detail::iterator_defaults<Base,Value> default_traits;

    typedef typename ct_if< is_default<Reference_>::value,
      typename default_traits::reference, Reference_>::type Reference;

    typedef typename ct_if< is_default<Pointer_>::value,
      typename default_traits::pointer, Pointer_>::type Pointer;

    typedef typename ct_if< is_default<Category_>::value,
      typename base_traits::iterator_category, Category_>::type Category;

    typedef typename ct_if< is_default<Distance_>::value,
      typename base_traits::difference_type, Distance_>::type Distance;
    
  public:
    typedef iterator_adaptor<Base, Policies, Value, Reference, Pointer,
      Category, Distance> type;
  };
  
} // namespace boost