diff DEPENDENCIES/generic/include/boost/python/args.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/python/args.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,175 @@
+// 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