#include <boost/iterator_adaptors.hpp>

//===========================================================================
// Named Template Parameter Helper
//
// provides resolve_default class template
//


namespace boost {

struct default_argument { };

namespace detail {

  struct dummy_default_gen {
    template <class Base, class Traits>
    struct bind {
      typedef default_argument type;
    };
  };
}

// This is a workaround for VC++
template <class Gen> struct default_generator {
  typedef detail::dummy_default_gen type;
};

// Use this macro at global scope
#define BOOST_NAMED_TEMPLATE_PARAMETER(NAME, DEFAULT) \
namespace boost { \
  template <> struct default_generator<DEFAULT> { \
    typedef DEFAULT type; \
  }; \
}

namespace detail {
  
  template <class T> struct is_default { enum { value = false }; };
  template <> struct is_default<default_argument> { enum { value = true }; };

  struct choose_default {
    template <class Base, class Traits, class Arg, class DefaultGen>
    struct bind {
      typedef typename default_generator<DefaultGen>::type Gen;
      typedef typename Gen::template bind<Base,Traits>::type type;
    };
  };
  struct choose_arg {
    template <class Base, class Traits, class Arg, class DefaultGen>
    struct bind {
      typedef Arg type;
    };
  };
  template <bool UseDefault>
  struct choose_arg_or_default { typedef choose_arg type; };
  template <>
  struct choose_arg_or_default<true> { typedef choose_default type; };

} // namesace detail

  template <class Arg, class DefaultGen, class Base, class Traits>
  class resolve_default {
    typedef typename detail::choose_arg_or_default
      <detail::is_default<Arg>::value>::type Selector;
  public:
    typedef typename Selector
      ::template bind<Base,Traits,Arg,DefaultGen>::type type;
  };

} // namespace boost


//===========================================================================
// Iterator Adaptor Generator

namespace boost {
namespace detail {

struct default_value_type {
  template <class Base, class Traits>
  struct bind {
    typedef boost::detail::iterator_traits<Base>::value_type type;
  };
};
struct default_difference_type {
  template <class Base, class Traits>
  struct bind {
    typedef boost::detail::iterator_traits<Base>::difference_type type;
  };
};
struct default_iterator_category {
  template <class Base, class Traits>
  struct bind {
    typedef boost::detail::iterator_traits<Base>::iterator_category type;
  };
};
struct default_pointer {
  template <class Base, class Traits>
  struct bind {
    typedef typename Traits::value_type Value;
    typedef typename boost::detail::iterator_defaults<Base,Value>::pointer 
      type;
  };
};
struct default_reference {
  template <class Base, class Traits>
  struct bind {
    typedef typename Traits::value_type Value;
    typedef typename boost::detail::iterator_defaults<Base,Value>::reference 
      type;
  };
};

} // namespace detail
} // namespace boost

BOOST_NAMED_TEMPLATE_PARAMETER(value_type, boost::detail::default_value_type);
BOOST_NAMED_TEMPLATE_PARAMETER(reference, boost::detail::default_reference);
BOOST_NAMED_TEMPLATE_PARAMETER(pointer, boost::detail::default_pointer);
BOOST_NAMED_TEMPLATE_PARAMETER(difference_type, boost::detail::default_difference_type);
BOOST_NAMED_TEMPLATE_PARAMETER(iterator_category, boost::detail::default_iterator_category);

namespace boost {
namespace detail {

  template <class V = default_argument, 
            class R = default_argument, 
            class P = default_argument,
            class C = default_argument,
            class D = default_argument>
  struct make_iterator_adaptor_types {
    template <class T>
    struct value_type : public make_iterator_adaptor_types<T,R,P,C,D> { };
    template <class T>
    struct reference : public make_iterator_adaptor_types<V,T,P,C,D> { };
    template <class T>
    struct pointer : public make_iterator_adaptor_types<V,R,T,C,D> { };
    template <class T>
    struct iterator_category : public make_iterator_adaptor_types<V,R,P,T,D>{};
    template <class T>
    struct difference_type : public make_iterator_adaptor_types<V,R,P,C,T> { };

    typedef boost::iterator<C, V, D, P, R> type;
  };
} // namespace detail

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

template <class Base, class Policies, class Traits>
struct iterator_adaptor_generator
{
  typedef typename resolve_default<typename Traits::value_type, 
    detail::default_value_type, Base, Traits>::type Value;
  typedef typename resolve_default<typename Traits::difference_type, 
    detail::default_difference_type, Base, Traits>::type Distance;
  typedef typename resolve_default<typename Traits::iterator_category, 
    detail::default_iterator_category, Base, Traits>::type Category;

  typedef typename Traits::pointer Pointer_;
  typedef typename Traits::reference Reference_;

  typedef boost::iterator<Category, Value, Distance, Pointer_, Reference_> 
    Traits2;

  typedef typename resolve_default<typename Traits2::reference, 
    detail::default_reference, Base, Traits2>::type Reference;
  typedef typename resolve_default<typename Traits2::pointer, 
    detail::default_pointer, Base, Traits2>::type Pointer;
  
  typedef boost::iterator_adaptor<Base, Policies, Value, Reference, 
    Pointer, Category, Distance> type;
};

} // namespace boost

int
main()
{
  int* ptr;
  typedef 
    boost::iterator_adaptor_generator<int*, boost::default_iterator_policies,
      boost::iterator_adaptor_types
      ::reference<int>
      ::iterator_category<std::input_iterator_tag>::type
    >::type Iter;

  Iter x(ptr);

  return 0;
}