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