// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
// sell and distribute this software is granted provided this
// copyright notice appears in all copies. This software is provided
// "as is" without express or implied warranty, and with no claim as
// to its suitability for any purpose.

#ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
#define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP

#include <boost/type_traits/conversion_traits.hpp>
#include <boost/type_traits/same_traits.hpp>
#include <boost/type_traits/composite_traits.hpp> // for is_reference
#include <boost/pending/ct_if.hpp>
#if defined(__BORLANDC__)
#include <boost/type_traits/ice.hpp>
#endif

namespace boost {

  // To differentiate an unnamed parameter from a traits generator
  // we use is_convertible<X, iter_traits_gen_base>.
  struct named_template_param_base { };

  namespace detail {
    
    struct default_argument { };

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

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

    template <class T> struct is_default { 
      enum { value = false };  
      typedef type_traits::no_type type;
    };
    template <> struct is_default<default_argument> { 
      enum { value = true }; 
      typedef type_traits::yes_type type;
    };

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

#if defined(__BORLANDC__)
    template <class UseDefault>
    struct choose_arg_or_default { typedef choose_arg type; };
    template <>
    struct choose_arg_or_default<type_traits::yes_type> {
      typedef choose_default type;
    };
#else
    template <bool UseDefault>
    struct choose_arg_or_default { typedef choose_arg type; };
    template <>
    struct choose_arg_or_default<true> {
      typedef choose_default type;
    };
#endif
    
    template <class Arg, class DefaultGen, class Base, class Traits>
    class resolve_default {
#if defined(__BORLANDC__)
      typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector;
#else
      // This usually works for Borland, but I'm seeing weird errors in
      // iterator_adaptor_test.cpp when using this method.
      enum { is_def = is_default<Arg>::value };
      typedef typename choose_arg_or_default<is_def>::type Selector;
#endif
    public:
      typedef typename Selector
        ::template bind<Arg, DefaultGen, Base, Traits>::type type;
    };

    template <class X>
    struct is_named_param_list {
      enum { value  = is_convertible<X, named_template_param_base>::value };
    };
    
    struct choose_named_params {
      template <class Prev> struct bind { typedef Prev type; };
    };
    struct choose_default_arg {
      template <class Prev> struct bind { 
        typedef detail::default_argument type;
      };
    };

    template <bool Named> struct choose_default_dispatch { };
    template <> struct choose_default_dispatch<true> {
      typedef choose_named_params type;
    };
    template <> struct choose_default_dispatch<false> {
      typedef choose_default_arg type;
    };


    template <class PreviousArg>
    struct choose_default_argument {
      enum { is_named = is_named_param_list<PreviousArg>::value };
      typedef typename choose_default_dispatch<is_named>::type Selector;
      typedef typename Selector::template bind<PreviousArg>::type type;
    };

    // This macro assumes that there is a class named default_##TYPE
    // defined before the application of the macro.  This class should
    // have a single member class template named "bind" with two
    // template parameters: the type of the class being created (e.g.,
    // the iterator_adaptor type when creating iterator adaptors) and
    // a traits class. The bind class should have a single typedef
    // named "type" that produces the default for TYPE.  See
    // boost/iterator_adaptors.hpp for an example usage.  Also,
    // applications of this macro must be placed in namespace
    // boost::detail.

#define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \
    template <> struct default_generator<default_##TYPE> { \
      typedef default_##TYPE type; \
    }

  } // namespace detail

  struct list_end_type { };

  namespace detail {
    template <class List> 
    struct find_param_impl {
      template <class Tag> class bind {
	typedef typename List::first_type Param;
	typedef typename List::second_type Rest;
	typedef typename find_param_impl<Rest>::template bind<Tag>::type RestType;
	enum { is_same_tag = is_same<typename Param::tag, Tag>::value };
      public:
	typedef typename ct_if<is_same_tag,
	  typename Param::type, RestType>::type type;
      };
    };
    template <> 
    struct find_param_impl<list_end_type> {
      template <class Tag> struct bind {
	typedef default_argument type;
      };
    };
  } //namespace detail

  template <class List, class Tag> struct find_param {
    typedef typename detail::find_param_impl<List>::template bind<Tag>::type type;
  };

  template <class T, class Tag>
  struct param_p {
    typedef T type;
    typedef Tag tag;
  };
  template <class T, class Tag>
  struct wrap_param {
    enum { is_named_param = is_convertible<T, named_template_param_base>::value };
    typedef typename ct_if<is_named_param, T, param_p<T, Tag> >::type type;
  };

} // namespace boost

#endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP