stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/include/boost/compute/closure.hpp

@@ -0,0 +1,347 @@
+//---------------------------------------------------------------------------//
+// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
+//
+// 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
+//
+// See http://boostorg.github.com/compute for more information.
+//---------------------------------------------------------------------------//
+
+#ifndef BOOST_COMPUTE_CLOSURE_HPP
+#define BOOST_COMPUTE_CLOSURE_HPP
+
+#include <string>
+#include <sstream>
+
+#include <boost/config.hpp>
+#include <boost/fusion/adapted/boost_tuple.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/function_traits.hpp>
+
+#include <boost/compute/cl.hpp>
+#include <boost/compute/function.hpp>
+#include <boost/compute/type_traits/type_name.hpp>
+#include <boost/compute/type_traits/detail/capture_traits.hpp>
+
+namespace boost {
+namespace compute {
+namespace detail {
+
+template<class ResultType, class ArgTuple, class CaptureTuple>
+class invoked_closure
+{
+public:
+    typedef ResultType result_type;
+
+    BOOST_STATIC_CONSTANT(
+        size_t, arity = boost::tuples::length<ArgTuple>::value
+    );
+
+    invoked_closure(const std::string &name,
+                    const std::string &source,
+                    const std::map<std::string, std::string> &definitions,
+                    const ArgTuple &args,
+                    const CaptureTuple &capture)
+        : m_name(name),
+          m_source(source),
+          m_definitions(definitions),
+          m_args(args),
+          m_capture(capture)
+    {
+    }
+
+    std::string name() const
+    {
+        return m_name;
+    }
+
+    std::string source() const
+    {
+        return m_source;
+    }
+
+    const std::map<std::string, std::string>& definitions() const
+    {
+        return m_definitions;
+    }
+
+    const ArgTuple& args() const
+    {
+        return m_args;
+    }
+
+    const CaptureTuple& capture() const
+    {
+        return m_capture;
+    }
+
+private:
+    std::string m_name;
+    std::string m_source;
+    std::map<std::string, std::string> m_definitions;
+    ArgTuple m_args;
+    CaptureTuple m_capture;
+};
+
+} // end detail namespace
+
+/// \internal_
+template<class Signature, class CaptureTuple>
+class closure
+{
+public:
+    typedef typename
+        boost::function_traits<Signature>::result_type result_type;
+
+    BOOST_STATIC_CONSTANT(
+        size_t, arity = boost::function_traits<Signature>::arity
+    );
+
+    closure(const std::string &name,
+            const CaptureTuple &capture,
+            const std::string &source)
+        : m_name(name),
+          m_source(source),
+          m_capture(capture)
+    {
+    }
+
+    ~closure()
+    {
+    }
+
+    std::string name() const
+    {
+        return m_name;
+    }
+
+    /// \internal_
+    std::string source() const
+    {
+        return m_source;
+    }
+
+    /// \internal_
+    void define(std::string name, std::string value = std::string())
+    {
+        m_definitions[name] = value;
+    }
+
+    /// \internal_
+    detail::invoked_closure<result_type, boost::tuple<>, CaptureTuple>
+    operator()() const
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            arity == 0,
+            "Non-nullary closure function invoked with zero arguments"
+        );
+
+        return detail::invoked_closure<result_type, boost::tuple<>, CaptureTuple>(
+            m_name, m_source, m_definitions, boost::make_tuple(), m_capture
+        );
+    }
+
+    /// \internal_
+    template<class Arg1>
+    detail::invoked_closure<result_type, boost::tuple<Arg1>, CaptureTuple>
+    operator()(const Arg1 &arg1) const
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            arity == 1,
+            "Non-unary closure function invoked with one argument"
+        );
+
+        return detail::invoked_closure<result_type, boost::tuple<Arg1>, CaptureTuple>(
+            m_name, m_source, m_definitions, boost::make_tuple(arg1), m_capture
+        );
+    }
+
+    /// \internal_
+    template<class Arg1, class Arg2>
+    detail::invoked_closure<result_type, boost::tuple<Arg1, Arg2>, CaptureTuple>
+    operator()(const Arg1 &arg1, const Arg2 &arg2) const
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            arity == 2,
+            "Non-binary closure function invoked with two arguments"
+        );
+
+        return detail::invoked_closure<result_type, boost::tuple<Arg1, Arg2>, CaptureTuple>(
+            m_name, m_source, m_definitions, boost::make_tuple(arg1, arg2), m_capture
+        );
+    }
+
+    /// \internal_
+    template<class Arg1, class Arg2, class Arg3>
+    detail::invoked_closure<result_type, boost::tuple<Arg1, Arg2, Arg3>, CaptureTuple>
+    operator()(const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3) const
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            arity == 3,
+            "Non-ternary closure function invoked with three arguments"
+        );
+
+        return detail::invoked_closure<result_type, boost::tuple<Arg1, Arg2, Arg3>, CaptureTuple>(
+            m_name, m_source, m_definitions, boost::make_tuple(arg1, arg2, arg3), m_capture
+        );
+    }
+
+private:
+    std::string m_name;
+    std::string m_source;
+    std::map<std::string, std::string> m_definitions;
+    CaptureTuple m_capture;
+};
+
+namespace detail {
+
+struct closure_signature_argument_inserter
+{
+    closure_signature_argument_inserter(std::stringstream &s_,
+                                        const char *capture_string,
+                                        size_t last)
+        : s(s_)
+    {
+        n = 0;
+        m_last = last;
+
+        size_t capture_string_length = std::strlen(capture_string);
+        BOOST_ASSERT(capture_string[0] == '(' &&
+                     capture_string[capture_string_length-1] == ')');
+        std::string capture_string_(capture_string + 1, capture_string_length - 2);
+        boost::split(m_capture_names, capture_string_ , boost::is_any_of(","));
+    }
+
+    template<class T>
+    void operator()(const T&) const
+    {
+        BOOST_ASSERT(n < m_capture_names.size());
+
+        // get captured variable name
+        std::string variable_name = m_capture_names[n];
+
+        // remove leading and trailing whitespace from variable name
+        boost::trim(variable_name);
+
+        s << capture_traits<T>::type_name() << " " << variable_name;
+        if(n+1 < m_last){
+            s << ", ";
+        }
+        n++;
+    }
+
+    mutable size_t n;
+    size_t m_last;
+    std::vector<std::string> m_capture_names;
+    std::stringstream &s;
+};
+
+template<class Signature, class CaptureTuple>
+inline std::string
+make_closure_declaration(const char *name,
+                         const char *arguments,
+                         const CaptureTuple &capture_tuple,
+                         const char *capture_string)
+{
+    typedef typename
+        boost::function_traits<Signature>::result_type result_type;
+    typedef typename
+        boost::function_types::parameter_types<Signature>::type parameter_types;
+    typedef typename
+        mpl::size<parameter_types>::type arity_type;
+
+    std::stringstream s;
+    s << "inline " << type_name<result_type>() << " " << name;
+    s << "(";
+
+    // insert function arguments
+    signature_argument_inserter i(s, arguments, arity_type::value);
+    mpl::for_each<
+        typename mpl::transform<parameter_types, boost::add_pointer<mpl::_1>
+    >::type>(i);
+    s << ", ";
+
+    // insert capture arguments
+    closure_signature_argument_inserter j(
+        s, capture_string, boost::tuples::length<CaptureTuple>::value
+    );
+    fusion::for_each(capture_tuple, j);
+
+    s << ")";
+    return s.str();
+}
+
+// used by the BOOST_COMPUTE_CLOSURE() macro to create a closure
+// function with the given signature, name, capture, and source.
+template<class Signature, class CaptureTuple>
+inline closure<Signature, CaptureTuple>
+make_closure_impl(const char *name,
+                  const char *arguments,
+                  const CaptureTuple &capture,
+                  const char *capture_string,
+                  const std::string &source)
+{
+    std::stringstream s;
+    s << make_closure_declaration<Signature>(name, arguments, capture, capture_string);
+    s << source;
+
+    return closure<Signature, CaptureTuple>(name, capture, s.str());
+}
+
+} // end detail namespace
+} // end compute namespace
+} // end boost namespace
+
+/// Creates a closure function object with \p name and \p source.
+///
+/// \param return_type The return type for the function.
+/// \param name The name of the function.
+/// \param arguments A list of arguments for the function.
+/// \param capture A list of variables to capture.
+/// \param source The OpenCL C source code for the function.
+///
+/// For example, to create a function which checks if a 2D point is
+/// contained in a circle of a given radius:
+/// \code
+/// // radius variable declared in C++
+/// float radius = 1.5f;
+///
+/// // create a closure function which returns true if the 2D point
+/// // argument is contained within a circle of the given radius
+/// BOOST_COMPUTE_CLOSURE(bool, is_in_circle, (const float2_ p), (radius),
+/// {
+///     return sqrt(p.x*p.x + p.y*p.y) < radius;
+/// });
+///
+/// // vector of 2D points
+/// boost::compute::vector<float2_> points = ...
+///
+/// // count number of points in the circle
+/// size_t count = boost::compute::count_if(
+///     points.begin(), points.end(), is_in_circle, queue
+/// );
+/// \endcode
+///
+/// \see BOOST_COMPUTE_FUNCTION()
+#ifdef BOOST_COMPUTE_DOXYGEN_INVOKED
+#define BOOST_COMPUTE_CLOSURE(return_type, name, arguments, capture, source)
+#else
+#define BOOST_COMPUTE_CLOSURE(return_type, name, arguments, capture, ...) \
+    ::boost::compute::closure< \
+        return_type arguments, BOOST_TYPEOF(boost::tie capture) \
+    > name = \
+        ::boost::compute::detail::make_closure_impl< \
+            return_type arguments \
+        >( \
+            #name, #arguments, boost::tie capture, #capture, #__VA_ARGS__ \
+        )
+#endif
+
+#endif // BOOST_COMPUTE_CLOSURE_HPP