// Copyright David Abrahams 2002.

 // Distributed under the Boost Software License, Version 1.0. (See

 // accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 #ifndef KEYWORDS_DWA2002323_HPP

 # define KEYWORDS_DWA2002323_HPP

 # include <boost/python/detail/prefix.hpp>

 # include <boost/python/args_fwd.hpp>

 # include <boost/config.hpp>

 # include <boost/python/detail/preprocessor.hpp>

 # include <boost/python/detail/type_list.hpp>

 # include <boost/type_traits/is_reference.hpp>

 # include <boost/type_traits/remove_reference.hpp>

 # include <boost/type_traits/remove_cv.hpp>

 # include <boost/preprocessor/enum_params.hpp>

 # include <boost/preprocessor/repeat.hpp>

 # include <boost/preprocessor/facilities/intercept.hpp>

 # include <boost/preprocessor/iteration/local.hpp>

 # include <boost/python/detail/mpl_lambda.hpp>

 # include <boost/python/object_core.hpp>

 # include <boost/mpl/bool.hpp>

 # include <cstddef>

 # include <algorithm>

 namespace boost { namespace python {

 typedef detail::keywords<1> arg;

 typedef arg arg_; // gcc 2.96 workaround

 namespace detail

 {

   template <std::size_t nkeywords>

   struct keywords_base

   {

       BOOST_STATIC_CONSTANT(std::size_t, size = nkeywords);

       keyword_range range() const

       {

           return keyword_range(elements, elements + nkeywords);

       }

       keyword elements[nkeywords];

       keywords<nkeywords+1>

       operator,(python::arg const &k) const;

       keywords<nkeywords + 1>

       operator,(char const *name) const;

   };

   template <std::size_t nkeywords>

   struct keywords : keywords_base<nkeywords>

   {

   };

   template <>

   struct keywords<1> : keywords_base<1>

   {

       explicit keywords(char const *name)

       {

           elements[0].name = name;

       }

       template <class T>

       python::arg& operator=(T const& value)

       {

           object z(value);

           elements[0].default_value = handle<>(python::borrowed(object(value).ptr()));

           return *this;

       }

       operator detail::keyword const&() const

       {

           return elements[0];

       }

   };

   template <std::size_t nkeywords>

   inline

   keywords<nkeywords+1>

   keywords_base<nkeywords>::operator,(python::arg const &k) const

   {

       keywords<nkeywords> const& l = *static_cast<keywords<nkeywords> const*>(this);

       python::detail::keywords<nkeywords+1> res;

       std::copy(l.elements, l.elements+nkeywords, res.elements);

       res.elements[nkeywords] = k.elements[0];

       return res;

   }

   template <std::size_t nkeywords>

   inline

   keywords<nkeywords + 1>

   keywords_base<nkeywords>::operator,(char const *name) const

   {

       return this->operator,(python::arg(name));

   }

 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

   template<typename T>

   struct is_keywords

   {

       BOOST_STATIC_CONSTANT(bool, value = false); 

   };

   template<std::size_t nkeywords>

   struct is_keywords<keywords<nkeywords> >

   {

       BOOST_STATIC_CONSTANT(bool, value = true);

   };

   template <class T>

   struct is_reference_to_keywords

   {

       BOOST_STATIC_CONSTANT(bool, is_ref = is_reference<T>::value);

       typedef typename remove_reference<T>::type deref;

       typedef typename remove_cv<deref>::type key_t;

       BOOST_STATIC_CONSTANT(bool, is_key = is_keywords<key_t>::value);

       BOOST_STATIC_CONSTANT(bool, value = (is_ref & is_key));

       typedef mpl::bool_<value> type;

       BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))

   };

 # else 

   typedef char (&yes_keywords_t)[1];

   typedef char (&no_keywords_t)[2];

   no_keywords_t is_keywords_test(...);

   template<std::size_t nkeywords>

   yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords>&));

   template<std::size_t nkeywords>

   yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords> const&));

   template<typename T>

   class is_reference_to_keywords

   {

    public:

       BOOST_STATIC_CONSTANT(

           bool, value = (

               sizeof(detail::is_keywords_test( (void (*)(T))0 ))

               == sizeof(detail::yes_keywords_t)));

       typedef mpl::bool_<value> type;

       BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))

   };

 # endif 

 }

 inline detail::keywords<1> args(char const* name)

 { 

     return detail::keywords<1>(name);

 }

 #  define BOOST_PYTHON_ASSIGN_NAME(z, n, _) result.elements[n].name = name##n;

 #  define BOOST_PP_LOCAL_MACRO(n)                                               \

 inline detail::keywords<n> args(BOOST_PP_ENUM_PARAMS_Z(1, n, char const* name)) \

 {                                                                               \

     detail::keywords<n> result;                                                 \

     BOOST_PP_REPEAT_1(n, BOOST_PYTHON_ASSIGN_NAME, _)                           \

     return result;                                                              \

 }

 #  define BOOST_PP_LOCAL_LIMITS (2, BOOST_PYTHON_MAX_ARITY)

 #  include BOOST_PP_LOCAL_ITERATE()

 }} // namespace boost::python

 # endif // KEYWORDS_DWA2002323_HPP