]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | |
2 | // Copyright (C) 2009-2012 Lorenzo Caminiti | |
3 | // Distributed under the Boost Software License, Version 1.0 | |
4 | // (see accompanying file LICENSE_1_0.txt or a copy at | |
5 | // http://www.boost.org/LICENSE_1_0.txt) | |
6 | // Home at http://www.boost.org/libs/local_function | |
7 | ||
8 | #ifndef BOOST_LOCAL_FUNCTION_HPP_ | |
9 | #define BOOST_LOCAL_FUNCTION_HPP_ | |
10 | ||
11 | #ifndef DOXYGEN | |
12 | ||
13 | #include <boost/local_function/aux_/macro/decl.hpp> | |
14 | #include <boost/local_function/aux_/macro/name.hpp> | |
15 | #include <boost/local_function/aux_/macro/typeof.hpp> | |
16 | #include <boost/local_function/aux_/preprocessor/traits/decl.hpp> | |
17 | #include <boost/local_function/detail/preprocessor/line_counter.hpp> | |
18 | #include <boost/local_function/detail/preprocessor/void_list.hpp> | |
19 | #include <boost/config.hpp> | |
20 | ||
21 | // PUBLIC // | |
22 | ||
23 | #ifdef BOOST_NO_CXX11_VARIADIC_MACROS | |
24 | # define BOOST_LOCAL_FUNCTION_ID(id, declarations) \ | |
25 | BOOST_LOCAL_FUNCTION_AUX_DECL(id, 0 /* not within template */, \ | |
26 | BOOST_LOCAL_FUNCTION_AUX_PP_DECL_TRAITS( \ | |
27 | BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST( \ | |
28 | declarations))) | |
29 | # define BOOST_LOCAL_FUNCTION(declarations) \ | |
30 | BOOST_LOCAL_FUNCTION_ID( \ | |
31 | BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, declarations) | |
32 | # define BOOST_LOCAL_FUNCTION_ID_TPL(id, declarations) \ | |
33 | BOOST_LOCAL_FUNCTION_AUX_DECL(id, 1 /* within template */, \ | |
34 | BOOST_LOCAL_FUNCTION_AUX_PP_DECL_TRAITS( \ | |
35 | BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST( \ | |
36 | declarations))) | |
37 | # define BOOST_LOCAL_FUNCTION_TPL(declarations) \ | |
38 | BOOST_LOCAL_FUNCTION_ID_TPL( \ | |
39 | BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, declarations) | |
40 | #else // VARIADIC | |
41 | # define BOOST_LOCAL_FUNCTION_ID(id, ...) \ | |
42 | BOOST_LOCAL_FUNCTION_AUX_DECL(id, 0 /* not within template */, \ | |
43 | BOOST_LOCAL_FUNCTION_AUX_PP_DECL_TRAITS( \ | |
44 | BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST(__VA_ARGS__))) | |
45 | # define BOOST_LOCAL_FUNCTION(...) \ | |
46 | BOOST_LOCAL_FUNCTION_ID( \ | |
47 | BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, __VA_ARGS__) | |
48 | # define BOOST_LOCAL_FUNCTION_ID_TPL(id, ...) \ | |
49 | BOOST_LOCAL_FUNCTION_AUX_DECL(id, 1 /* within template */, \ | |
50 | BOOST_LOCAL_FUNCTION_AUX_PP_DECL_TRAITS( \ | |
51 | BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST(__VA_ARGS__))) | |
52 | # define BOOST_LOCAL_FUNCTION_TPL(...) \ | |
53 | BOOST_LOCAL_FUNCTION_ID_TPL( \ | |
54 | BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, __VA_ARGS__) | |
55 | #endif // VARIADIC | |
56 | ||
57 | #define BOOST_LOCAL_FUNCTION_NAME(qualified_name) \ | |
58 | BOOST_LOCAL_FUNCTION_AUX_NAME(0 /* not within template */, qualified_name) | |
59 | #define BOOST_LOCAL_FUNCTION_NAME_TPL(qualified_name) \ | |
60 | BOOST_LOCAL_FUNCTION_AUX_NAME(1 /* within template */, qualified_name) | |
61 | ||
62 | #define BOOST_LOCAL_FUNCTION_TYPEOF(bound_variable_name) \ | |
63 | BOOST_LOCAL_FUNCTION_AUX_TYPEOF_TYPE(bound_variable_name) | |
64 | ||
65 | // DOCUMENTATION // | |
66 | ||
67 | #else // DOXYGEN | |
68 | ||
69 | /** @file | |
70 | @brief Local functions allow to program functions locally, within other | |
71 | functions, and directly within the scope where they are needed. | |
72 | */ | |
73 | ||
74 | /** | |
75 | @brief This macro is used to start a local function declaration. | |
76 | ||
77 | This macro must be used within a declarative context, it must follow the local | |
78 | function result type, it must be followed by the local function body code, and | |
79 | then by the @RefMacro{BOOST_LOCAL_FUNCTION_NAME} macro (see the | |
80 | @RefSect{tutorial, Tutorial} and @RefSect{advanced_topics, Advanced Topics} | |
81 | sections): | |
82 | @code | |
83 | { // Some declarative context. | |
84 | ... | |
85 | result_type BOOST_LOCAL_FUNCTION(declarations) { | |
86 | ... // Body code. | |
87 | } BOOST_LOCAL_FUNCTION_NAME(qualified_name) | |
88 | ... | |
89 | } | |
90 | @endcode | |
91 | ||
92 | As usual, exceptions specifications can be optionally programmed just after the | |
93 | macro and before the body code block <c>{ ... }</c> (but the exception | |
94 | specifications will only apply to the body code and not to the library code | |
95 | automatically generated by the macro expansion, see the | |
96 | @RefSect{advanced_topics, Advanced Topics} section). | |
97 | ||
98 | Within templates, the special macros @RefMacro{BOOST_LOCAL_FUNCTION_TPL} | |
99 | and @RefMacro{BOOST_LOCAL_FUNCTION_NAME_TPL} must be used. | |
100 | ||
101 | @Params | |
102 | @Param{declarations, | |
103 | On compilers that support variadic macros\, the parameter declarations are | |
104 | defined by the following grammar: | |
105 | @code | |
106 | declarations: | |
107 | void | declaration_tuple | declaration_sequence | |
108 | declaration_tuple: | |
109 | declaration\, declaration\, ... | |
110 | declaration_sequence: | |
111 | (declaration) (declaration) ... | |
112 | declaration: | |
113 | bound_variable | parameter | default_value | result_type | |
114 | bound_variable: | |
115 | [const] bind [(variable_type)] [&] variable_name | |
116 | parameter: | |
117 | [auto | register] parameter_type parameter_name | |
118 | default_value: | |
119 | default parameter_default_value | |
120 | result_type: | |
121 | return function_result_type | |
122 | @endcode | |
123 | On compilers that do not support variadic macros\, <c>declaration_tuple</c> | |
124 | cannot be used: | |
125 | @code | |
126 | declarations: | |
127 | void | declaration_sequence | |
128 | @endcode | |
129 | ||
130 | (Lexical conventions: <c>token1 | token2</c> means either <c>token1</c> or | |
131 | <c>token2</c>; <c>[token]</c> means either <c>token</c> or nothing; | |
132 | <c>{expression}</c> means the token resulting from the expression.) | |
133 | } | |
134 | @EndParams | |
135 | ||
136 | Note that on compilers that support variadic macros, commas can be used to | |
137 | separate the declarations resembling more closely the usual C++ function | |
138 | declaration syntax (this is the preferred syntax). | |
139 | However, for portability, on all C++ compilers (with and without variadic | |
140 | macros) the same library macros also accept parameter declarations specified as | |
141 | a Boost.Preprocessor sequence separated by round parenthesis <c>()</c>. | |
142 | ||
143 | When binding the object <c>this</c>, the special symbol <c>this_</c> needs to | |
144 | be used instead of <c>this</c> as the name of the variable to bind and also | |
145 | within the local function body to access the object. | |
146 | (Mistakenly using <c>this</c> instead of <c>this_</c> might not always result in a compiler error and will in general result in undefined behaviour.) | |
147 | ||
148 | The result type must either be specified just before the macro or within the | |
149 | macro declarations prefixed by <c>return</c> (but not in both places). | |
150 | ||
151 | Within the local function body it possible to access the result type using <c>result_type</c>, the type of the first parameter using <c>arg1_type</c>, the type of the second parameter using <c>arg2_type</c>, etc. | |
152 | The bound variable types can be accessed using @RefMacro{BOOST_LOCAL_FUNCTION_TYPEOF}. | |
153 | ||
154 | This macro cannot be portably expanded multiple times on the same line. | |
155 | In these cases, use the @RefMacro{BOOST_LOCAL_FUNCTION_ID} macro instead. | |
156 | ||
157 | The maximum number of local function parameters (excluding bound variables) is | |
158 | specified by the configuration macro | |
159 | @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_ARITY_MAX}. | |
160 | The maximum number of bound variables is specified by the configuration macro | |
161 | @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_BIND_MAX}. | |
162 | The configuration macro | |
163 | @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_LOCALS_AS_TPARAMS} can be used to force | |
164 | optimizations that reduce the local function call run-time overhead. | |
165 | ||
166 | @Note Local functions are functors so they can be assigned to other functors | |
167 | like <c>boost::function</c> (see Boost.Function). | |
168 | ||
169 | @See @RefSect{tutorial, Tutorial} section, | |
170 | @RefSect{advanced_topics, Advanced Topics} section, | |
171 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME}, @RefMacro{BOOST_LOCAL_FUNCTION_TPL}, | |
172 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME_TPL}, | |
173 | @RefMacro{BOOST_LOCAL_FUNCTION_TYPEOF}, @RefMacro{BOOST_LOCAL_FUNCTION_ID}, | |
174 | @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_ARITY_MAX}, | |
175 | @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_BIND_MAX}, | |
176 | @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_LOCALS_AS_TPARAMS}. | |
177 | */ | |
178 | #define BOOST_LOCAL_FUNCTION(declarations) | |
179 | ||
180 | /** | |
181 | @brief This macro is used to start a local function declaration within | |
182 | templates. | |
183 | ||
184 | This macro must be used instead of @RefMacro{BOOST_LOCAL_FUNCTION} when | |
185 | declaring a local function within a template. | |
186 | A part from that, this macro has the exact same syntax a | |
187 | @RefMacro{BOOST_LOCAL_FUNCTION} (see @RefMacro{BOOST_LOCAL_FUNCTION} for more | |
188 | information): | |
189 | @code | |
190 | { // Some declarative context within a template. | |
191 | ... | |
192 | result_type BOOST_LOCAL_FUNCTION_TPL(declarations) { | |
193 | ... // Body code. | |
194 | } BOOST_LOCAL_FUNCTION_NAME_TPL(qualified_name) | |
195 | ... | |
196 | } | |
197 | @endcode | |
198 | ||
199 | Note that @RefMacro{BOOST_LOCAL_FUNCTION_NAME_TPL} must be used with this | |
200 | macro instead of @RefMacro{BOOST_LOCAL_FUNCTION_NAME}. | |
201 | ||
202 | This macro cannot be portably expanded multiple times on the same line. | |
203 | In these cases, use the @RefMacro{BOOST_LOCAL_FUNCTION_ID_TPL} macro instead. | |
204 | ||
205 | @Note C++03 does not allow to use <c>typename</c> outside templates. | |
206 | This library internally manipulates types, these operations require | |
207 | <c>typename</c> but only within templates. | |
208 | This macro is used to indicate to the library when the enclosing scope is a | |
209 | template so the library can correctly use <c>typename</c>. | |
210 | ||
211 | @See @RefSect{tutorial, Tutorial} section, @RefMacro{BOOST_LOCAL_FUNCTION}, | |
212 | @RefMacro{BOOST_LOCAL_FUNCTION_ID_TPL}, | |
213 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME_TPL}. | |
214 | */ | |
215 | #define BOOST_LOCAL_FUNCTION_TPL(declarations) | |
216 | ||
217 | /** | |
218 | @brief This macro allows to declare multiple local functions on the same line. | |
219 | ||
220 | This macro is equivalent to @RefMacro{BOOST_LOCAL_FUNCTION} but it can be | |
221 | expanded multiple times on the same line if different identifiers <c>id</c> are | |
222 | provided for each expansion (see the | |
223 | @RefSect{advanced_topics, Advanced Topics} section). | |
224 | ||
225 | @Params | |
226 | @Param{id, | |
227 | A unique identifier token which can be concatenated by the preprocessor | |
228 | (<c>__LINE__</c>\, <c>local_function_number_1_on_line_123</c>\, etc). | |
229 | } | |
230 | @Param{declarations, | |
231 | Same as the <c>declarations</c> parameter of the | |
232 | @RefMacro{BOOST_LOCAL_FUNCTION} macro. | |
233 | } | |
234 | @EndParams | |
235 | ||
236 | The @RefMacro{BOOST_LOCAL_FUNCTION_NAME} macro should be used to end each one | |
237 | of the multiple local function declarations as usual (and it will specify a | |
238 | unique name for each local function). | |
239 | ||
240 | Within templates, the special macros @RefMacro{BOOST_LOCAL_FUNCTION_ID_TPL} | |
241 | must be used. | |
242 | ||
243 | @Note This macro can be useful when the local function macros are expanded | |
244 | within user-defined macros (because macros all expand on the same line). | |
245 | On some compilers (e.g., MSVC which supports the non-standard | |
246 | <c>__COUNTER__</c> macro) it might not be necessary to use this macro but | |
247 | the use of this macro when expanding multiple local function macros on the same | |
248 | line is always necessary to ensure portability (this is because this library | |
249 | can only portably use <c>__LINE__</c> to internally generate unique | |
250 | identifiers). | |
251 | ||
252 | @See @RefSect{advanced_topics, Advanced Topics} section, | |
253 | @RefMacro{BOOST_LOCAL_FUNCTION}, @RefMacro{BOOST_LOCAL_FUNCTION_NAME}, | |
254 | @RefMacro{BOOST_LOCAL_FUNCTION_ID_TPL}. | |
255 | */ | |
256 | #define BOOST_LOCAL_FUNCTION_ID(id, declarations) | |
257 | ||
258 | /** | |
259 | @brief This macro allows to declare multiple local functions on the same line | |
260 | within templates. | |
261 | ||
262 | This macro must be used instead of @RefMacro{BOOST_LOCAL_FUNCTION_TPL} when | |
263 | declaring multiple local functions on the same line within a template. | |
264 | A part from that, this macro has the exact same syntax as | |
265 | @RefMacro{BOOST_LOCAL_FUNCTION_TPL} (see @RefMacro{BOOST_LOCAL_FUNCTION_TPL} | |
266 | for more information). | |
267 | ||
268 | @Params | |
269 | @Param{id, | |
270 | A unique identifier token which can be concatenated by the preprocessor | |
271 | (<c>__LINE__</c>\, <c>local_function_number_1_on_line_123</c>\, etc). | |
272 | } | |
273 | @Param{declarations, | |
274 | Same as the <c>declarations</c> parameter of the | |
275 | @RefMacro{BOOST_LOCAL_FUNCTION_TPL} macro. | |
276 | } | |
277 | @EndParams | |
278 | ||
279 | The @RefMacro{BOOST_LOCAL_FUNCTION_NAME} macro should be used to end each one | |
280 | of the multiple local function declarations as usual (and it will specify a | |
281 | unique name for each local function). | |
282 | ||
283 | Outside template, the macro @RefMacro{BOOST_LOCAL_FUNCTION_ID} should be used | |
284 | to declare multiple local functions on the same line. | |
285 | ||
286 | @Note This macro can be useful when the local function macros are expanded | |
287 | within user-defined macros (because macros all expand on the same line). | |
288 | On some compilers (e.g., MSVC which supports the non-standard | |
289 | <c>__COUNTER__</c> macro) it might not be necessary to use this macro but | |
290 | the use of this macro when expanding multiple local function macros on the same | |
291 | line is always necessary to ensure portability (this is because this library | |
292 | can only portably use <c>__LINE__</c> to internally generate unique | |
293 | identifiers). | |
294 | ||
295 | @See @RefSect{advanced_topics, Advanced Topics} section, | |
296 | @RefMacro{BOOST_LOCAL_FUNCTION_TPL}, @RefMacro{BOOST_LOCAL_FUNCTION_NAME}, | |
297 | @RefMacro{BOOST_LOCAL_FUNCTION_ID}. | |
298 | */ | |
299 | #define BOOST_LOCAL_FUNCTION_ID_TPL(id, declarations) | |
300 | ||
301 | /** | |
302 | @brief This macro is used to end a local function declaration specifying its | |
303 | name. | |
304 | ||
305 | This macro must follow the local function body code block <c>{ ... }</c>: | |
306 | @code | |
307 | { // Some declarative context. | |
308 | ... | |
309 | result_type BOOST_LOCAL_FUNCTION(declarations) { | |
310 | ... // Body code. | |
311 | } BOOST_LOCAL_FUNCTION_NAME(qualified_name) | |
312 | ... | |
313 | } | |
314 | @endcode | |
315 | ||
316 | Within templates, the special macros @RefMacro{BOOST_LOCAL_FUNCTION_TPL} and | |
317 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME_TPL} must be used. | |
318 | ||
319 | @Params | |
320 | @Param{qualified_name, | |
321 | The name of the local function optionally qualified as follow: | |
322 | @code | |
323 | name: | |
324 | [inline] [recursive] local_function_name | |
325 | @endcode | |
326 | (Lexical conventions: <c>token1 | token2</c> means either <c>token1</c> or | |
327 | <c>token2</c>; <c>[token]</c> means either <c>token</c> or nothing; | |
328 | <c>{expression}</c> means the token resulting from the expression.) | |
329 | } | |
330 | @EndParams | |
331 | ||
332 | The local function name can be qualified by prefixing it with the keyword | |
333 | <c>inline</c> (see the @RefSect{advanced_topics, Advanced Topics} section): | |
334 | @code | |
335 | BOOST_LOCAL_FUNCTION_NAME(inline local_function_name) | |
336 | @endcode | |
337 | This increases the chances that the compiler will be able to inline the local | |
338 | function calls (thus reducing run-time). | |
339 | However, inline local functions cannot be passed as template parameters (e.g., to <c>std::for_each</c>) or assigned to other functors (e.g., to | |
340 | <c>boost::function</c>). | |
341 | That is true on C++03 compilers but inline local functions can instead be | |
342 | passed as template parameters on C++11 compilers. | |
343 | On C++11 compilers, there is no need to declare a local function lined because | |
344 | this library will automatically use C++11 specific features to inline the local | |
345 | function while always allowing to pass it as a template parameter. | |
346 | This optimization is automatically enabled when the Boost.Config macro | |
347 | <c>BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS</c> is not defined but it also be | |
348 | forced using @RefMacro{BOOST_LOCAL_FUNCTION_CONFIG_LOCALS_AS_TPARAMS}. | |
349 | ||
350 | The local function name can also be qualified by prefixing it with the | |
351 | "keyword" <c>recursive</c> (see the | |
352 | @RefSect{advanced_topics, Advanced Topics} section): | |
353 | @code | |
354 | BOOST_LOCAL_FUNCTION_NAME(recursive local_function_name) | |
355 | @endcode | |
356 | This allows the local function to recursively call itself from its body (as | |
357 | usual in C++). | |
358 | However, recursive local functions should only be called within their | |
359 | declaration scope (otherwise the result is undefined behaviour). | |
360 | Finally, compilers have not been observed to be able to inline recursive local | |
361 | function calls, not even when the recursive local function is also declared | |
362 | inline: | |
363 | @code | |
364 | BOOST_LOCAL_FUNCTION(inline recursive local_function_name) | |
365 | @endcode | |
366 | ||
367 | @Note The local function name cannot be the name of an operator | |
368 | <c>operator...</c> and it cannot be the same name of another local function | |
369 | declared within the same enclosing scope (but <c>boost::overloaded_function</c> | |
370 | can be used to overload local functions, see | |
371 | Boost.Functional/OverloadedFunction and the | |
372 | @RefSect{advanced_topics, Advanced Topics} section). | |
373 | ||
374 | @See @RefSect{tutorial, Tutorial} section, | |
375 | @RefSect{advanced_topics, Advanced Topics} section, | |
376 | @RefMacro{BOOST_LOCAL_FUNCTION}, | |
377 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME_TPL}. | |
378 | */ | |
379 | #define BOOST_LOCAL_FUNCTION_NAME(qualified_name) | |
380 | ||
381 | /** | |
382 | @brief This macro is used to end a local function declaration specifying its | |
383 | name within templates. | |
384 | ||
385 | This macro must be used instead of @RefMacro{BOOST_LOCAL_FUNCTION_NAME} when | |
386 | declaring a local function within a template. | |
387 | A part from that, this macro has the exact same syntax a | |
388 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME} (see @RefMacro{BOOST_LOCAL_FUNCTION_NAME} | |
389 | for more information): | |
390 | @code | |
391 | { // Some declarative context within a template. | |
392 | ... | |
393 | result_type BOOST_LOCAL_FUNCTION_TPL(declarations) { | |
394 | ... // Body code. | |
395 | } BOOST_LOCAL_FUNCTION_NAME_TPL(qualified_name) | |
396 | ... | |
397 | } | |
398 | @endcode | |
399 | ||
400 | Note that @RefMacro{BOOST_LOCAL_FUNCTION_TPL} must be used with this macro | |
401 | instead of @RefMacro{BOOST_LOCAL_FUNCTION}. | |
402 | ||
403 | @Note C++03 does not allow to use <c>typename</c> outside templates. | |
404 | This library internally manipulates types, these operations require | |
405 | <c>typename</c> but only within templates. | |
406 | This macro is used to indicate to the library when the enclosing scope is a | |
407 | template so the library can correctly use <c>typename</c>. | |
408 | ||
409 | @See @RefSect{tutorial, Tutorial} section, | |
410 | @RefMacro{BOOST_LOCAL_FUNCTION_NAME}, @RefMacro{BOOST_LOCAL_FUNCTION_TPL}. | |
411 | */ | |
412 | #define BOOST_LOCAL_FUNCTION_NAME_TPL(name) | |
413 | ||
414 | /** | |
415 | @brief This macro expands to the type of the specified bound variable. | |
416 | ||
417 | This macro can be used within the local functions body to refer to the bound | |
418 | variable types so to declare local variables, check concepts (using | |
419 | Boost.ConceptCheck), etc (see the @RefSect{advanced_topics, Advanced Topics} | |
420 | section). | |
421 | This way the local function can be programmed entirely without explicitly | |
422 | specifying the bound variable types thus facilitating maintenance (e.g., if | |
423 | the type of a bound variable changes in the enclosing scope, the local function | |
424 | code does not have to change). | |
425 | ||
426 | @Params | |
427 | @Param{bound_variable_name, | |
428 | The name of one of the local function's bound variables. | |
429 | } | |
430 | @EndParams | |
431 | ||
432 | The type returned by the macro is fully qualified in that it contains the extra | |
433 | constant and reference qualifiers when the specified variable is bound by | |
434 | constant and by reference. | |
435 | For example, if a variable named <c>t</c> of type <c>T</c> is: | |
436 | @li Bound by value using <c>bind t</c> then | |
437 | <c>BOOST_LOCAL_FUNCTION_TYPEOF(t)</c> is <c>T</c>. | |
438 | @li Bound by constant value using <c>const bind t</c> then | |
439 | <c>BOOST_LOCAL_FUNCTION_TYPEOF(t)</c> is <c>const T</c>. | |
440 | @li Bound by reference using <c>bind& t</c> then | |
441 | <c>BOOST_LOCAL_FUNCTION_TYPEOF(t)</c> is <c>T&</c>. | |
442 | @li Bound by constant reference using <c>const bind& t</c> then | |
443 | <c>BOOST_LOCAL_FUNCTION_TYPEOF(t)</c> is <c>const T&</c>. | |
444 | ||
445 | This macro must be prefixed by <c>typename</c> when used within templates. | |
446 | ||
447 | @Note It is best to use this macro instead of Boost.Typeof so to reduce the | |
448 | number of times Boost.Typeof is used to deduce types (see the | |
449 | @RefSect{advanced_topics, Advanced Topics} section). | |
450 | ||
451 | @See @RefSect{advanced_topics, Advanced Topics} section, | |
452 | @RefMacro{BOOST_LOCAL_FUNCTION}. | |
453 | */ | |
454 | #define BOOST_LOCAL_FUNCTION_TYPEOF(bound_variable_name) | |
455 | ||
456 | #endif // DOXYGEN | |
457 | ||
458 | #endif // #include guard | |
459 |