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/type_traits/is_const.hpp>
  11 #include <boost/utility/enable_if.hpp>
  12 #include <boost/fusion/support/is_sequence.hpp>
  13
  14 namespace boost { namespace fusion
  15 {
  16     namespace extension
  17     {
  18         template <typename Tag>
  19         struct at_impl;
  20
  21         template <typename Tag>
  22         struct begin_impl;
  23
  24         template <typename Tag>
  25         struct empty_impl;
  26
  27         template <typename Tag>
  28         struct end_impl;
  29
  30         template <typename Tag>
  31         struct has_key_impl;
  32
  33         template <typename Tag>
  34         struct segments_impl;
  35
  36         template <typename Tag>
  37         struct size_impl;
  38
  39         template <typename Tag>
  40         struct value_at_impl;
  41
  42         template <typename Tag>
  43         struct at_key_impl;
  44
  45         template <typename Tag>
  46         struct value_at_key_impl;
  47     }
  48
  49     namespace result_of
  50     {
  51         template <typename Sequence, typename N>
  52         struct at;
  53
  54         template <typename Sequence, int N>
  55         struct at_c;
  56
  57         template <typename Sequence>
  58         struct back;
  59
  60         template <typename Sequence>
  61         struct begin;
  62
  63         template <typename Sequence>
  64         struct empty;
  65
  66         template <typename Sequence>
  67         struct end;
  68
  69         template <typename Sequence>
  70         struct front;
  71
  72         template <typename Sequence, typename Key>
  73         struct has_key;
  74
  75         template <typename Sequence>
  76         struct segments;
  77
  78         template <typename Sequence>
  79         struct size;
  80
  81         template <typename Sequence, typename N>
  82         struct value_at;
  83
  84         template <typename Sequence, int N>
  85         struct value_at_c;
  86
  87         template <typename Sequence, typename Key>
  88         struct at_key;
  89
  90         template <typename Sequence, typename N>
  91         struct value_at_key;
  92     }
  93
  94     template <typename N, typename Sequence>
  95     typename
  96         lazy_disable_if<
  97             is_const<Sequence>
  98           , result_of::at<Sequence, N>
  99         >::type
 100     at(Sequence& seq);
 101
 102     template <typename N, typename Sequence>
 103     typename result_of::at<Sequence const, N>::type
 104     at(Sequence const& seq);
 105
 106     template <int N, typename Sequence>
 107     typename
 108         lazy_disable_if<
 109             is_const<Sequence>
 110           , result_of::at_c<Sequence, N>
 111         >::type
 112     at_c(Sequence& seq);
 113
 114     template <int N, typename Sequence>
 115     typename result_of::at_c<Sequence const, N>::type
 116     at_c(Sequence const& seq);
 117
 118     template <typename Sequence>
 119     typename result_of::back<Sequence>::type
 120     back(Sequence& seq);
 121
 122     template <typename Sequence>
 123     typename result_of::back<Sequence const>::type
 124     back(Sequence const& seq);
 125
 126     template <typename Sequence>
 127     typename
 128         lazy_enable_if<
 129             traits::is_sequence<Sequence>
 130           , result_of::begin<Sequence>
 131         >::type const
 132     begin(Sequence& seq);
 133
 134     template <typename Sequence>
 135     typename
 136         lazy_enable_if<
 137             traits::is_sequence<Sequence>
 138           , result_of::begin<Sequence const>
 139         >::type const
 140     begin(Sequence const& seq);
 141
 142     template <typename Sequence>
 143     typename result_of::empty<Sequence>::type
 144     empty(Sequence const&);
 145
 146     template <typename Sequence>
 147     typename
 148         lazy_enable_if<
 149             traits::is_sequence<Sequence>
 150           , result_of::end<Sequence>
 151         >::type const
 152     end(Sequence& seq);
 153
 154     template <typename Sequence>
 155     typename
 156         lazy_enable_if<
 157             traits::is_sequence<Sequence>
 158           , result_of::end<Sequence const>
 159         >::type const
 160     end(Sequence const& seq);
 161
 162     template <typename Sequence>
 163     typename result_of::front<Sequence>::type
 164     front(Sequence& seq);
 165
 166     template <typename Sequence>
 167     typename result_of::front<Sequence const>::type
 168     front(Sequence const& seq);
 169
 170     template <typename Key, typename Sequence>
 171     typename result_of::has_key<Sequence, Key>::type
 172     has_key(Sequence const& seq);
 173
 174     template <typename Sequence>
 175     typename
 176         lazy_disable_if<
 177             is_const<Sequence>
 178           , result_of::segments<Sequence>
 179         >::type
 180     segments(Sequence& seq);
 181
 182     template <typename Sequence>
 183     typename result_of::segments<Sequence const>::type
 184     segments(Sequence const& seq);
 185
 186     template <typename Sequence>
 187     typename result_of::size<Sequence>::type
 188     size(Sequence const&);
 189
 190     template <typename Key, typename Sequence>
 191     typename
 192         lazy_disable_if<
 193             is_const<Sequence>
 194           , result_of::at_key<Sequence, Key>
 195         >::type
 196     at_key(Sequence& seq);
 197
 198     template <typename Key, typename Sequence>
 199     typename result_of::at_key<Sequence const, Key>::type
 200     at_key(Sequence const& seq);
 201 }}
 202
 203 #endif