ceph/src/boost/boost/fusion/sequence/intrinsic_fwd.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2011 Joel de Guzman
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 ==============================================================================*/
   7 #if !defined(BOOST_FUSION_SEQUENCE_INTRINSIC_FWD_HPP_INCLUDED)
   8 #define BOOST_FUSION_SEQUENCE_INTRINSIC_FWD_HPP_INCLUDED
   9
  10 #include <boost/fusion/support/config.hpp>
  11 #include <boost/type_traits/is_const.hpp>
  12 #include <boost/utility/enable_if.hpp>
  13 #include <boost/fusion/support/is_sequence.hpp>
  14
  15 namespace boost { namespace fusion
  16 {
  17     namespace extension
  18     {
  19         template <typename Tag>
  20         struct at_impl;
  21
  22         template <typename Tag>
  23         struct begin_impl;
  24
  25         template <typename Tag>
  26         struct empty_impl;
  27
  28         template <typename Tag>
  29         struct end_impl;
  30
  31         template <typename Tag>
  32         struct has_key_impl;
  33
  34         template <typename Tag>
  35         struct segments_impl;
  36
  37         template <typename Tag>
  38         struct size_impl;
  39
  40         template <typename Tag>
  41         struct value_at_impl;
  42
  43         template <typename Tag>
  44         struct at_key_impl;
  45
  46         template <typename Tag>
  47         struct value_at_key_impl;
  48     }
  49
  50     namespace result_of
  51     {
  52         template <typename Sequence, typename N>
  53         struct at;
  54
  55         template <typename Sequence, int N>
  56         struct at_c;
  57
  58         template <typename Sequence>
  59         struct back;
  60
  61         template <typename Sequence>
  62         struct begin;
  63
  64         template <typename Sequence>
  65         struct empty;
  66
  67         template <typename Sequence>
  68         struct end;
  69
  70         template <typename Sequence>
  71         struct front;
  72
  73         template <typename Sequence, typename Key>
  74         struct has_key;
  75
  76         template <typename Sequence>
  77         struct segments;
  78
  79         template <typename Sequence>
  80         struct size;
  81
  82         template <typename Sequence, typename N>
  83         struct value_at;
  84
  85         template <typename Sequence, int N>
  86         struct value_at_c;
  87
  88         template <typename Sequence, typename Key>
  89         struct at_key;
  90
  91         template <typename Sequence, typename N>
  92         struct value_at_key;
  93     }
  94
  95     template <typename N, typename Sequence>
  96     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
  97     typename
  98         lazy_disable_if<
  99             is_const<Sequence>
 100           , result_of::at<Sequence, N>
 101         >::type
 102     at(Sequence& seq);
 103
 104     template <typename N, typename Sequence>
 105     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 106     typename result_of::at<Sequence const, N>::type
 107     at(Sequence const& seq);
 108
 109     template <int N, typename Sequence>
 110     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 111     typename
 112         lazy_disable_if<
 113             is_const<Sequence>
 114           , result_of::at_c<Sequence, N>
 115         >::type
 116     at_c(Sequence& seq);
 117
 118     template <int N, typename Sequence>
 119     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 120     typename result_of::at_c<Sequence const, N>::type
 121     at_c(Sequence const& seq);
 122
 123     template <typename Sequence>
 124     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 125     typename result_of::back<Sequence>::type
 126     back(Sequence& seq);
 127
 128     template <typename Sequence>
 129     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 130     typename result_of::back<Sequence const>::type
 131     back(Sequence const& seq);
 132
 133     template <typename Sequence>
 134     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 135     typename
 136         lazy_enable_if<
 137             traits::is_sequence<Sequence>
 138           , result_of::begin<Sequence>
 139         >::type const
 140     begin(Sequence& seq);
 141
 142     template <typename Sequence>
 143     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 144     typename
 145         lazy_enable_if<
 146             traits::is_sequence<Sequence>
 147           , result_of::begin<Sequence const>
 148         >::type const
 149     begin(Sequence const& seq);
 150
 151     template <typename Sequence>
 152     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 153     typename result_of::empty<Sequence>::type
 154     empty(Sequence const&);
 155
 156     template <typename Sequence>
 157     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 158     typename
 159         lazy_enable_if<
 160             traits::is_sequence<Sequence>
 161           , result_of::end<Sequence>
 162         >::type const
 163     end(Sequence& seq);
 164
 165     template <typename Sequence>
 166     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 167     typename
 168         lazy_enable_if<
 169             traits::is_sequence<Sequence>
 170           , result_of::end<Sequence const>
 171         >::type const
 172     end(Sequence const& seq);
 173
 174     template <typename Sequence>
 175     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 176     typename result_of::front<Sequence>::type
 177     front(Sequence& seq);
 178
 179     template <typename Sequence>
 180     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 181     typename result_of::front<Sequence const>::type
 182     front(Sequence const& seq);
 183
 184     template <typename Key, typename Sequence>
 185     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 186     typename result_of::has_key<Sequence, Key>::type
 187     has_key(Sequence const& seq);
 188
 189     template <typename Sequence>
 190     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 191     typename
 192         lazy_disable_if<
 193             is_const<Sequence>
 194           , result_of::segments<Sequence>
 195         >::type
 196     segments(Sequence& seq);
 197
 198     template <typename Sequence>
 199     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 200     typename result_of::segments<Sequence const>::type
 201     segments(Sequence const& seq);
 202
 203     template <typename Sequence>
 204     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 205     typename result_of::size<Sequence>::type
 206     size(Sequence const&);
 207
 208     template <typename Key, typename Sequence>
 209     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 210     typename
 211         lazy_disable_if<
 212             is_const<Sequence>
 213           , result_of::at_key<Sequence, Key>
 214         >::type
 215     at_key(Sequence& seq);
 216
 217     template <typename Key, typename Sequence>
 218     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
 219     typename result_of::at_key<Sequence const, Key>::type
 220     at_key(Sequence const& seq);
 221 }}
 222
 223 #endif