epoc32/include/stdapis/boost/lambda/detail/actions.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
williamr@2
     1
// -- Boost Lambda Library - actions.hpp ----------------------------------
williamr@2
     2
williamr@2
     3
// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
williamr@2
     4
//
williamr@2
     5
// Distributed under the Boost Software License, Version 1.0. (See
williamr@2
     6
// accompanying file LICENSE_1_0.txt or copy at
williamr@2
     7
// http://www.boost.org/LICENSE_1_0.txt)
williamr@2
     8
williamr@2
     9
// For more information, see www.boost.org
williamr@2
    10
williamr@2
    11
// ----------------------------------------------------------------
williamr@2
    12
williamr@2
    13
#ifndef BOOST_LAMBDA_ACTIONS_HPP
williamr@2
    14
#define BOOST_LAMBDA_ACTIONS_HPP
williamr@2
    15
williamr@2
    16
namespace boost { 
williamr@2
    17
namespace lambda {
williamr@2
    18
williamr@2
    19
williamr@2
    20
williamr@2
    21
template<int Arity, class Act> class action;
williamr@2
    22
williamr@2
    23
// these need to be defined here, since the corresponding lambda 
williamr@2
    24
// functions are members of lambda_functor classes
williamr@2
    25
williamr@2
    26
class assignment_action {};
williamr@2
    27
class subscript_action {};
williamr@2
    28
williamr@2
    29
template <class Action> class other_action;
williamr@2
    30
williamr@2
    31
// action for specifying the explicit return type
williamr@2
    32
template <class RET> class explicit_return_type_action {};
williamr@2
    33
williamr@2
    34
// action for preventing the expansion of a lambda expression
williamr@2
    35
struct protect_action {};
williamr@2
    36
williamr@2
    37
  // must be defined here, comma is a special case
williamr@2
    38
struct comma_action {};
williamr@2
    39
williamr@2
    40
williamr@2
    41
  // actions, for which the existence of protect is checked in return type 
williamr@2
    42
  // deduction.
williamr@2
    43
williamr@2
    44
template <class Action> struct is_protectable {
williamr@2
    45
  BOOST_STATIC_CONSTANT(bool, value = false);
williamr@2
    46
};
williamr@2
    47
williamr@2
    48
// NOTE: comma action is protectable. Other protectable actions
williamr@2
    49
// are listed in operator_actions.hpp
williamr@2
    50
williamr@2
    51
template<> struct is_protectable<other_action<comma_action> > {
williamr@2
    52
  BOOST_STATIC_CONSTANT(bool, value = true);
williamr@2
    53
};
williamr@2
    54
williamr@2
    55
williamr@2
    56
namespace detail {
williamr@2
    57
williamr@2
    58
  // this type is used in return type deductions to signal that deduction 
williamr@2
    59
  // did not find a result. It does not necessarily mean an error, it commonly
williamr@2
    60
  // means that something else should be tried.
williamr@2
    61
  class unspecified {};
williamr@2
    62
}
williamr@2
    63
williamr@2
    64
  // function action is a special case: bind functions can be called with 
williamr@2
    65
  // the return type specialized explicitly e.g. bind<int>(foo);
williamr@2
    66
  // If this call syntax is used, the return type is stored in the latter
williamr@2
    67
  // argument of function_action template. Otherwise the argument gets the type
williamr@2
    68
  // 'unspecified'.
williamr@2
    69
  // This argument is only relevant in the return type deduction code
williamr@2
    70
template <int I, class Result_type = detail::unspecified> 
williamr@2
    71
class function_action {};
williamr@2
    72
   
williamr@2
    73
template<class T> class function_action<1, T> {
williamr@2
    74
public:
williamr@2
    75
  template<class RET, class A1>
williamr@2
    76
  static RET apply(A1& a1) {
williamr@2
    77
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
    78
      template apply<RET>(a1);
williamr@2
    79
  }
williamr@2
    80
};
williamr@2
    81
williamr@2
    82
template<class T> class function_action<2, T> {
williamr@2
    83
public:
williamr@2
    84
  template<class RET, class A1, class A2>
williamr@2
    85
  static RET apply(A1& a1, A2& a2) {
williamr@2
    86
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
    87
      template apply<RET>(a1, a2);
williamr@2
    88
  }
williamr@2
    89
};
williamr@2
    90
williamr@2
    91
template<class T> class function_action<3, T> {
williamr@2
    92
public:
williamr@2
    93
  template<class RET, class A1, class A2, class A3>
williamr@2
    94
  static RET apply(A1& a1, A2& a2, A3& a3) {
williamr@2
    95
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
    96
      template apply<RET>(a1, a2, a3);
williamr@2
    97
  }
williamr@2
    98
};
williamr@2
    99
williamr@2
   100
template<class T> class function_action<4, T> {
williamr@2
   101
public:
williamr@2
   102
  template<class RET, class A1, class A2, class A3, class A4>
williamr@2
   103
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2
   104
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   105
      template apply<RET>(a1, a2, a3, a4);
williamr@2
   106
  }
williamr@2
   107
};
williamr@2
   108
williamr@2
   109
template<class T> class function_action<5, T> {
williamr@2
   110
public:
williamr@2
   111
  template<class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2
   112
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2
   113
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   114
      template apply<RET>(a1, a2, a3, a4, a5);
williamr@2
   115
  }
williamr@2
   116
};
williamr@2
   117
williamr@2
   118
template<class T> class function_action<6, T> {
williamr@2
   119
public:
williamr@2
   120
  template<class RET, class A1, class A2, class A3, class A4, class A5, 
williamr@2
   121
           class A6>
williamr@2
   122
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2
   123
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   124
      template apply<RET>(a1, a2, a3, a4, a5, a6);
williamr@2
   125
  }
williamr@2
   126
};
williamr@2
   127
williamr@2
   128
template<class T> class function_action<7, T> {
williamr@2
   129
public:
williamr@2
   130
  template<class RET, class A1, class A2, class A3, class A4, class A5,  
williamr@2
   131
           class A6, class A7>
williamr@2
   132
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2
   133
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   134
      template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
williamr@2
   135
  }
williamr@2
   136
};
williamr@2
   137
williamr@2
   138
template<class T> class function_action<8, T> {
williamr@2
   139
public:
williamr@2
   140
  template<class RET, class A1, class A2, class A3, class A4, class A5, 
williamr@2
   141
           class A6, class A7, class A8>
williamr@2
   142
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
williamr@2
   143
                   A8& a8) {
williamr@2
   144
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   145
      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2
   146
  }
williamr@2
   147
};
williamr@2
   148
williamr@2
   149
template<class T> class function_action<9, T> {
williamr@2
   150
public:
williamr@2
   151
  template<class RET, class A1, class A2, class A3, class A4, class A5, 
williamr@2
   152
           class A6, class A7, class A8, class A9>
williamr@2
   153
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
williamr@2
   154
                   A8& a8, A9& a9) {
williamr@2
   155
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   156
      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2
   157
  }
williamr@2
   158
};
williamr@2
   159
williamr@2
   160
template<class T> class function_action<10, T> {
williamr@2
   161
public:
williamr@2
   162
  template<class RET, class A1, class A2, class A3, class A4, class A5, 
williamr@2
   163
           class A6, class A7, class A8, class A9, class A10>
williamr@2
   164
  static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, 
williamr@2
   165
                   A8& a8, A9& a9, A10& a10) {
williamr@2
   166
    return function_adaptor<typename boost::remove_cv<A1>::type>::
williamr@2
   167
      template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
williamr@2
   168
  }
williamr@2
   169
};
williamr@2
   170
williamr@2
   171
} // namespace lambda
williamr@2
   172
} // namespace boost
williamr@2
   173
williamr@2
   174
#endif