comparison DEPENDENCIES/generic/include/boost/fusion/sequence/intrinsic/at.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_AT_05042005_0722)
 #define FUSION_AT_05042005_0722
 
+#include <boost/fusion/support/config.hpp>
 #include <boost/mpl/int.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/empty_base.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/fusion/sequence/intrinsic_fwd.hpp>
 #include <boost/fusion/support/tag_of.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 

 
         template <>
         struct at_impl<std_tuple_tag>;
     }
 
+    namespace detail
+    {
+        template <typename Sequence, typename N, typename Tag>
+        struct at_impl
+            : mpl::if_<
+                  mpl::less<N, typename extension::size_impl<Tag>::template apply<Sequence>::type>
+                , typename extension::at_impl<Tag>::template apply<Sequence, N>
+                , mpl::empty_base
+              >::type
+        {};
+    }
+
     namespace result_of
     {
         template <typename Sequence, typename N>
         struct at
-            : extension::at_impl<typename detail::tag_of<Sequence>::type>::
-                template apply<Sequence, N>
+            : detail::at_impl<Sequence, N, typename detail::tag_of<Sequence>::type>
         {};
 
         template <typename Sequence, int N>
         struct at_c
             : at<Sequence, mpl::int_<N> >
         {};
     }
 
 
     template <typename N, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename
         lazy_disable_if<
             is_const<Sequence>
           , result_of::at<Sequence, N>
         >::type

     {
         return result_of::at<Sequence, N>::call(seq);
     }
 
     template <typename N, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::at<Sequence const, N>::type
     at(Sequence const& seq)
     {
         return result_of::at<Sequence const, N>::call(seq);
     }
 
     template <int N, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename
         lazy_disable_if<
             is_const<Sequence>
           , result_of::at_c<Sequence, N>
         >::type

     {
         return fusion::at<mpl::int_<N> >(seq);
     }
 
     template <int N, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::at_c<Sequence const, N>::type
     at_c(Sequence const& seq)
     {
         return fusion::at<mpl::int_<N> >(seq);
     }