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

depends/x86_64-pc-linux-gnu/include/boost/fusion/support/pair.hpp

@@ -0,0 +1,168 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Tobias Schwinger
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_PAIR_07222005_1203)
+#define FUSION_PAIR_07222005_1203
+
+#include <boost/fusion/support/config.hpp>
+#include <iosfwd>
+
+#include <boost/fusion/support/detail/access.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion
+{
+    // A half runtime pair where the first type does not have data
+    template <typename First, typename Second>
+    struct pair
+    {
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair()
+            : second() {}
+
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair(pair const& rhs)
+            : second(rhs.second) {}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair(pair&& rhs)
+            : second(BOOST_FUSION_FWD_ELEM(Second, rhs.second)) {}
+#endif
+
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair(typename detail::call_param<Second>::type val)
+            : second(val) {}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <typename Second2>
+        BOOST_FUSION_GPU_ENABLED
+        pair(Second2&& val
+          , typename boost::disable_if<is_lvalue_reference<Second2> >::type* /* dummy */ = 0
+          , typename boost::enable_if<is_convertible<Second2, Second> >::type* /*dummy*/ = 0
+        ) : second(BOOST_FUSION_FWD_ELEM(Second, val)) {}
+#endif
+
+        template <typename Second2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair(pair<First, Second2> const& rhs)
+            : second(rhs.second) {}
+
+        template <typename Second2>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair& operator=(pair<First, Second2> const& rhs)
+        {
+            second = rhs.second;
+            return *this;
+        }
+
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair& operator=(pair const& rhs)
+        {
+            second = rhs.second;
+            return *this;
+        }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair& operator=(pair&& rhs)
+        {
+            second = BOOST_FUSION_FWD_ELEM(Second, rhs.second);
+            return *this;
+        }
+#endif
+
+        typedef First first_type;
+        typedef Second second_type;
+        Second second;
+    };
+
+    namespace result_of
+    {
+        template<typename First, typename Second>
+        struct make_pair
+        {
+            typedef fusion::pair<First,
+                        typename detail::as_fusion_element<Second>::type> type;
+        };
+
+        template<class Pair>
+        struct first
+        {
+            typedef typename Pair::first_type type;
+        };
+
+        template<class Pair>
+        struct second
+        {
+            typedef typename Pair::second_type type;
+        };
+    }
+
+    template <typename First, typename Second>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::make_pair<First,Second>::type
+    make_pair(Second const& val)
+    {
+        return pair<First, typename detail::as_fusion_element<Second>::type>(val);
+    }
+
+    template <typename First, typename Second>
+    inline std::ostream&
+    operator<<(std::ostream& os, pair<First, Second> const& p)
+    {
+        os << p.second;
+        return os;
+    }
+
+    template <typename First, typename Second>
+    inline std::istream&
+    operator>>(std::istream& is, pair<First, Second>& p)
+    {
+        is >> p.second;
+        return is;
+    }
+
+    template <typename First, typename SecondL, typename SecondR>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    operator==(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
+    {
+        return l.second == r.second;
+    }
+
+    template <typename First, typename SecondL, typename SecondR>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    operator!=(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
+    {
+        return l.second != r.second;
+    }
+
+    template <typename First, typename SecondL, typename SecondR>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    operator<(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
+    {
+        return l.second < r.second;
+    }
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif