PageRenderTime 64ms CodeModel.GetById 19ms app.highlight 41ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/libs/parameter/test/preprocessor.cpp

http://hadesmem.googlecode.com/
C++ | 482 lines | 390 code | 69 blank | 23 comment | 12 complexity | 0f7b8e0979fc41c7c1378c84f63fb76b MD5 | raw file
  1// Copyright Daniel Wallin 2006. Use, modification and distribution is
  2// subject to the Boost Software License, Version 1.0. (See accompanying
  3// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  4
  5#include <boost/parameter/preprocessor.hpp>
  6#include <boost/parameter/keyword.hpp>
  7#include <boost/type_traits/is_const.hpp>
  8#include <string>
  9#include "basics.hpp"
 10
 11#ifndef BOOST_NO_SFINAE
 12# include <boost/utility/enable_if.hpp>
 13#endif
 14
 15namespace test {
 16
 17BOOST_PARAMETER_BASIC_FUNCTION((int), f, tag,
 18    (required
 19      (tester, *)
 20      (name, *)
 21    )
 22    (optional
 23      (value, *)
 24      (out(index), (int))
 25    )
 26)
 27{
 28    typedef typename boost::parameter::binding<
 29        Args, tag::index, int&
 30    >::type index_type;
 31
 32    BOOST_MPL_ASSERT((boost::is_same<index_type, int&>));
 33
 34    args[tester](
 35        args[name]
 36      , args[value | 1.f]
 37      , args[index | 2]
 38    );
 39
 40    return 1;
 41}
 42
 43BOOST_PARAMETER_BASIC_FUNCTION((int), g, tag,
 44    (required
 45      (tester, *)
 46      (name, *)
 47    )
 48    (optional
 49      (value, *)
 50      (out(index), (int))
 51    )
 52)
 53{
 54    typedef typename boost::parameter::binding<
 55        Args, tag::index, int const&
 56    >::type index_type;
 57
 58    BOOST_MPL_ASSERT((boost::is_same<index_type, int const&>));
 59
 60    args[tester](
 61        args[name]
 62      , args[value | 1.f]
 63      , args[index | 2]
 64    );
 65
 66    return 1;
 67}
 68
 69BOOST_PARAMETER_FUNCTION((int), h, tag,
 70    (required
 71      (tester, *)
 72      (name, *)
 73    )
 74    (optional
 75      (value, *, 1.f)
 76      (out(index), (int), 2)
 77    )
 78)
 79{
 80# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
 81  && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
 82    BOOST_MPL_ASSERT((boost::is_same<index_type, int>));
 83# endif
 84
 85    tester(
 86        name
 87      , value
 88      , index
 89    );
 90
 91    return 1;
 92}
 93
 94BOOST_PARAMETER_FUNCTION((int), h2, tag,
 95    (required
 96      (tester, *)
 97      (name, *)
 98    )
 99    (optional
100      (value, *, 1.f)
101      (out(index), (int), (int)value * 2)
102    )
103)
104{
105# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
106  && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
107    BOOST_MPL_ASSERT((boost::is_same<index_type, int>));
108# endif
109
110    tester(
111        name
112      , value
113      , index
114    );
115
116    return 1;
117}
118
119struct base
120{
121    template <class Args>
122    base(Args const& args)
123    {
124        args[tester](
125            args[name]
126          , args[value | 1.f]
127          , args[index | 2]
128        );
129    }
130};
131
132struct class_ : base
133{
134    BOOST_PARAMETER_CONSTRUCTOR(class_, (base), tag,
135        (required
136          (tester, *)
137          (name, *)
138        )
139        (optional
140          (value, *)
141          (index, *)
142        )
143    )
144
145    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((int), f, tag,
146        (required
147          (tester, *)
148          (name, *)
149        )
150        (optional
151          (value, *)
152          (index, *)
153        )
154    )
155    {
156        args[tester](
157            args[name]
158          , args[value | 1.f]
159          , args[index | 2]
160        );
161
162        return 1;
163    }
164
165    BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION((int), f, tag,
166        (required
167          (tester, *)
168          (name, *)
169        )
170        (optional
171          (value, *)
172          (index, *)
173        )
174    )
175    {
176        args[tester](
177            args[name]
178          , args[value | 1.f]
179          , args[index | 2]
180        );
181
182        return 1;
183    }
184
185    BOOST_PARAMETER_MEMBER_FUNCTION((int), f2, tag,
186        (required
187          (tester, *)
188          (name, *)
189        )
190        (optional
191          (value, *, 1.f)
192          (index, *, 2)
193        )
194    )
195    {
196        tester(name, value, index);
197        return 1;
198    }
199
200    BOOST_PARAMETER_CONST_MEMBER_FUNCTION((int), f2, tag,
201        (required
202          (tester, *)
203          (name, *)
204        )
205        (optional
206          (value, *, 1.f)
207          (index, *, 2)
208        )
209    )
210    {
211        tester(name, value, index);
212        return 1;
213    }
214
215
216    BOOST_PARAMETER_MEMBER_FUNCTION((int), static f_static, tag,
217        (required
218          (tester, *)
219          (name, *)
220        )
221        (optional
222          (value, *, 1.f)
223          (index, *, 2)
224        )
225    )
226    {
227        tester(name, value, index);
228        return 1;
229    }
230};
231
232BOOST_PARAMETER_FUNCTION(
233    (int), sfinae, tag,
234    (required
235       (name, (std::string))
236    )
237)
238{
239    return 1;
240}
241
242#ifndef BOOST_NO_SFINAE
243// On compilers that actually support SFINAE, add another overload
244// that is an equally good match and can only be in the overload set
245// when the others are not.  This tests that the SFINAE is actually
246// working.  On all other compilers we're just checking that
247// everything about SFINAE-enabled code will work, except of course
248// the SFINAE.
249template<class A0>
250typename boost::enable_if<boost::is_same<int,A0>, int>::type
251sfinae(A0 const& a0)
252{
253    return 0;
254}
255#endif
256
257#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
258
259// Sun has problems with this syntax:
260//
261//   template1< r* ( template2<x> ) >
262//
263// Workaround: factor template2<x> into a separate typedef
264typedef boost::is_convertible<boost::mpl::_, std::string> predicate;
265
266BOOST_PARAMETER_FUNCTION(
267    (int), sfinae1, tag,
268    (required
269       (name, *(predicate))
270    )
271)
272{
273    return 1;
274}
275
276#else
277
278BOOST_PARAMETER_FUNCTION(
279    (int), sfinae1, tag,
280    (required
281       (name, *(boost::is_convertible<boost::mpl::_, std::string>))
282    )
283)
284{
285    return 1;
286}
287#endif 
288
289#ifndef BOOST_NO_SFINAE
290// On compilers that actually support SFINAE, add another overload
291// that is an equally good match and can only be in the overload set
292// when the others are not.  This tests that the SFINAE is actually
293// working.  On all other compilers we're just checking that
294// everything about SFINAE-enabled code will work, except of course
295// the SFINAE.
296template<class A0>
297typename boost::enable_if<boost::is_same<int,A0>, int>::type
298sfinae1(A0 const& a0)
299{
300    return 0;
301}
302#endif
303
304template <class T>
305T const& as_lvalue(T const& x)
306{
307    return x;
308}
309
310struct udt
311{
312    udt(int foo, int bar)
313      : foo(foo)
314      , bar(bar)
315    {}
316
317    int foo;
318    int bar;
319};
320
321BOOST_PARAMETER_FUNCTION((int), lazy_defaults, tag,
322    (required
323      (name, *)
324    )
325    (optional
326      (value, *, name.foo)
327      (index, *, name.bar)
328    )
329)
330{
331    return 0;
332}
333
334} // namespace test
335
336int main()
337{
338    using namespace test;
339
340    f(
341        values(S("foo"), 1.f, 2)
342      , S("foo")
343    );
344
345    f(
346        tester = values(S("foo"), 1.f, 2)
347      , name = S("foo")
348    );
349
350    int index_lvalue = 2;
351
352    f(
353        tester = values(S("foo"), 1.f, 2)
354      , name = S("foo")
355      , value = 1.f
356      , test::index = index_lvalue
357    );
358
359    f(
360        values(S("foo"), 1.f, 2)
361      , S("foo")
362      , 1.f
363      , index_lvalue
364    );
365
366    g(
367        values(S("foo"), 1.f, 2)
368      , S("foo")
369      , 1.f
370#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
371      , as_lvalue(2)
372#else
373      , 2
374#endif
375    );
376
377    h(
378        values(S("foo"), 1.f, 2)
379      , S("foo")
380      , 1.f
381#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
382      , as_lvalue(2)
383#else
384      , 2
385#endif
386    );
387
388    h2(
389        tester = values(S("foo"), 1.f, 2)
390      , name = S("foo")
391      , value = 1.f
392    );
393
394    class_ x(
395        values(S("foo"), 1.f, 2)
396      , S("foo"), test::index = 2
397    );
398
399    x.f(
400        values(S("foo"), 1.f, 2)
401      , S("foo")
402    );
403
404    x.f(
405        tester = values(S("foo"), 1.f, 2)
406      , name = S("foo")
407    );
408
409    x.f2(
410        values(S("foo"), 1.f, 2)
411      , S("foo")
412    );
413
414    x.f2(
415        tester = values(S("foo"), 1.f, 2)
416      , name = S("foo")
417    );
418
419    class_ const& x_const = x;
420
421    x_const.f(
422        values(S("foo"), 1.f, 2)
423      , S("foo")
424    );
425
426    x_const.f(
427        tester = values(S("foo"), 1.f, 2)
428      , name = S("foo")
429    );
430
431    x_const.f2(
432        values(S("foo"), 1.f, 2)
433      , S("foo")
434    );
435
436    x_const.f2(
437        tester = values(S("foo"), 1.f, 2)
438      , name = S("foo")
439    );
440
441    x_const.f2(
442        tester = values(S("foo"), 1.f, 2)
443      , name = S("foo")
444    );
445
446    class_::f_static(
447        values(S("foo"), 1.f, 2)
448      , S("foo")
449    );
450
451    class_::f_static(
452        tester = values(S("foo"), 1.f, 2)
453      , name = S("foo")
454    );
455
456#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
457    assert(sfinae("foo") == 1);
458    assert(sfinae(1) == 0);
459
460# if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
461    // Sun actually eliminates the desired overload for some reason.
462    // Disabling this part of the test because SFINAE abilities are
463    // not the point of this test.
464    assert(sfinae1("foo") == 1);
465# endif
466    
467    assert(sfinae1(1) == 0);
468#endif
469
470    lazy_defaults(
471        name = udt(0,1)
472    );
473
474    lazy_defaults(
475        name = 0
476      , value = 1
477      , test::index = 2
478    );
479
480    return 0;
481}
482