// 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 

# include 
# include 
# include 
# include 
# include 

# include 
# include 
# include 
# include 

# include 
# include 

# include 

# include 
# include 

namespace boost { namespace python {

typedef detail::keywords arg;
typedef arg arg_; // gcc 2.96 workaround

namespace detail
{
  template 
  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
      operator,(python::arg const &k) const;

      keywords
      operator,(char const *name) const;
  };
  
  template 
  struct keywords : keywords_base
  {
  };

  template 
  struct keywords : keywords_base
  {
      explicit keywords(char const *name)
      {
          elements[0].name = name;
      }
    
      template 
      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 
  inline
  keywords
  keywords_base::operator,(python::arg const &k) const
  {
      keywords const& l = *static_cast(this);
      python::detail::keywords res;
      std::copy(l.elements, l.elements+nkeywords, res.elements);
      res.elements[nkeywords] = k.elements[0];
      return res;
  }

  template 
  inline
  keywords
  keywords_base::operator,(char const *name) const
  {
      return this->operator,(python::arg(name));
  }

  template
  struct is_keywords
  {
      BOOST_STATIC_CONSTANT(bool, value = false); 
  };

  template
  struct is_keywords
  {
      BOOST_STATIC_CONSTANT(bool, value = true);
  };
  template 
  struct is_reference_to_keywords
  {
      BOOST_STATIC_CONSTANT(bool, is_ref = detail::is_reference::value);
      typedef typename detail::remove_reference::type deref;
      typedef typename detail::remove_cv::type key_t;
      BOOST_STATIC_CONSTANT(bool, is_key = is_keywords::value);
      BOOST_STATIC_CONSTANT(bool, value = (is_ref & is_key));
      
      typedef mpl::bool_ type;
      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
  };
}

inline detail::keywords args(char const* name)
{ 
    return detail::keywords(name);
}

#  define BOOST_PYTHON_ASSIGN_NAME(z, n, _) result.elements[n].name = name##n;
#  define BOOST_PP_LOCAL_MACRO(n)                                               \
inline detail::keywords args(BOOST_PP_ENUM_PARAMS_Z(1, n, char const* name)) \
{                                                                               \
    detail::keywords 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