#include <boost/detail/iterator.hpp>
#include <boost/iterator_adaptors.hpp>

# if !defined(BOOST_MSVC)
#  define BOOST_ARG_DEPENDENT_TYPENAME typename
# else
#  define BOOST_ARG_DEPENDENT_TYPENAME
# endif

namespace boost {

namespace detail {

  struct no_default_parameter { };
  struct default_policies { };
  struct default_value { };
  struct default_pointer { };
  struct default_reference { };
  struct default_distance { };
  struct default_category { };

  template <typename Param>  
  struct get_default {
    template <typename Base, typename Policies, typename Value, 
      typename Reference, typename Category, typename Distance, 
      typename Pointer>
    struct bind { typedef Param type; };
  };

#define SET_DEFAULT(KEY) \
  template <> struct get_default<KEY> { \
    template <typename Base, typename Policies, typename Value, typename Reference, typename Category, typename Distance, typename Pointer> \
    struct bind { typedef 

#define DEFAULT_END type; };  }

#define gentype bind<true>::type

  SET_DEFAULT(default_policies) 
    default_iterator_policies 
  DEFAULT_END;
  SET_DEFAULT(default_value) 
    typename boost::detail::iterator_traits<Base>::value_type 
  DEFAULT_END;
  SET_DEFAULT(default_pointer)
    typename boost::detail::iterator_defaults<Base,Value>::pointer
  DEFAULT_END;
  SET_DEFAULT(default_distance) 
    typename boost::detail::iterator_traits<Base>::difference_type 
  DEFAULT_END;
  SET_DEFAULT(default_category) 
    typename boost::detail::iterator_traits<Base>::iterator_category 
  DEFAULT_END;
  SET_DEFAULT(default_reference) 
    typename boost::detail::iterator_defaults<Base,Value>::reference 
  DEFAULT_END;

  template <> struct get_default<no_default_parameter> { };
  
#define GET_DEFAULT(KEY) \
  typename get_default<KEY>::template bind<Base,Policies,Value,Reference,\
  Category,Distance,Pointer>::type
  

  template <bool B>
  struct generate_iter_adaptor { };

  template <>
  struct generate_iter_adaptor<true> {
    template <typename Base, typename Policies, typename Value,
	      typename Reference, typename Category, typename Distance,
	      typename Pointer>
    struct bind {
      typedef iterator_adaptor<
        GET_DEFAULT(Base), 
	GET_DEFAULT(Policies), GET_DEFAULT(Value), GET_DEFAULT(Reference), 
	GET_DEFAULT(Category), GET_DEFAULT(Distance), GET_DEFAULT(Pointer)
	> type;
    };
  };

  template <typename Base = no_default_parameter, 
    typename Policies = default_policies,
    typename Value     = default_value,
    typename Reference = default_reference,
    typename Category  = default_category,
    typename Distance  = default_distance,
    typename Pointer   = default_pointer
  >
  struct iterator_adaptor_types
  {
    template <bool B = true>
    struct end {
      typedef typename generate_iter_adaptor<B>::
      template bind<Base,Policies,Value,Reference,Category,Distance,Pointer>
      ::type type;
    };

    template <typename X> struct base 
    : iterator_adaptor_types<X,Policies,Value,Reference,Category,Distance,
      Pointer> { };

    template <typename X> struct policies 
    : iterator_adaptor_types<Base,X,Value,Reference,Category,Distance,
      Pointer> { };

    template <typename X> struct value 
    : iterator_adaptor_types<Base,Policies,X,Reference,Category,Distance,
      Pointer> { };

    template <typename X> struct reference 
    : iterator_adaptor_types<Base,Policies,Value,X,Category,Distance,
      Pointer> { };

    template <typename X> struct pointer 
    : iterator_adaptor_types<Base,Policies,Value,Reference,Category,Distance,
      X> { };

    template <typename X> struct category 
    : iterator_adaptor_types<Base,Policies,Value,Reference,X,Distance,
      Pointer> { };

    template <typename X> struct distance 
    : iterator_adaptor_types<Base,Policies,Value,Reference,Category,X,
      Pointer> { };
  };

} // namespace detail 

struct iterator_adaptor_generator
  : public detail::iterator_adaptor_types<> { };

} // namespace boost


int
main()
{
  int* x;
  boost::iterator_adaptor_generator
    ::base<int*>
    ::reference<const int&>
    ::policies<boost::reverse_iterator_policies>
    ::end<>::type iter(x);
  
  return 0;
}