comparison DEPENDENCIES/generic/include/boost/fusion/container/map/map.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(FUSION_MAP_MAIN_07212005_1106)
 #define FUSION_MAP_MAIN_07212005_1106
 
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/map/map_fwd.hpp>
 #include <boost/fusion/support/pair.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
 // Without variadics, we will use the PP version

 
         struct category : random_access_traversal_tag, associative_tag {};
         typedef mpl::int_<base_type::size> size;
         typedef mpl::false_ is_view;
 
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map() {}
 
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(map const& seq)
           : base_type(seq.base())
         {}
 
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(map&& seq)
           : base_type(std::forward<map>(seq))
         {}
 
         template <typename Sequence>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(Sequence const& seq
           , typename enable_if<traits::is_sequence<Sequence>>::type* /*dummy*/ = 0)
           : base_type(begin(seq), detail::map_impl_from_iterator())
         {}
 
         template <typename Sequence>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(Sequence& seq
           , typename enable_if<traits::is_sequence<Sequence>>::type* /*dummy*/ = 0)
           : base_type(begin(seq), detail::map_impl_from_iterator())
         {}
 
         template <typename Sequence>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(Sequence&& seq
           , typename enable_if<traits::is_sequence<Sequence>>::type* /*dummy*/ = 0)
           : base_type(begin(seq), detail::map_impl_from_iterator())
         {}
 
         template <typename First, typename ...T_>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(First const& first, T_ const&... rest)
           : base_type(first, rest...)
         {}
 
         template <typename First, typename ...T_>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map(First&& first, T_&&... rest)
-          : base_type(std::forward<First>(first), std::forward<T_>(rest)...)
+          : base_type(BOOST_FUSION_FWD_ELEM(First, first), BOOST_FUSION_FWD_ELEM(T_, rest)...)
         {}
 
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map& operator=(map const& rhs)
         {
             base_type::operator=(rhs.base());
             return *this;
         }
 
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         map& operator=(map&& rhs)
         {
             base_type::operator=(std::forward<base_type>(rhs.base()));
             return *this;
         }
 
         template <typename Sequence>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         typename enable_if<traits::is_sequence<Sequence>, map&>::type
         operator=(Sequence const& seq)
         {
             base().assign(begin(seq), detail::map_impl_from_iterator());
             return *this;
         }
 
-        base_type& base() { return *this; }
-        base_type const& base() const { return *this; }
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        base_type& base() BOOST_NOEXCEPT { return *this; }
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        base_type const& base() const BOOST_NOEXCEPT { return *this; }
     };
 }}
 
 #endif
 #endif