Mercurialtest / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
epoc32/include/stdapis/boost/bind/bind_template.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed. 
     1 //

     2 //  bind/bind_template.hpp

     3 //

     4 //  Do not include this header directly.

     5 //

     6 //  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.

     7 //

     8 // Distributed under the Boost Software License, Version 1.0. (See

     9 // accompanying file LICENSE_1_0.txt or copy at

    10 // http://www.boost.org/LICENSE_1_0.txt)

    11 //

    12 //  See http://www.boost.org/libs/bind/bind.html for documentation.

    13 //

    14 

    15     typedef typename result_traits<R, F>::type result_type;

    16 

    17     result_type operator()()

    18     {

    19         list0 a;

    20         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    21     }

    22 

    23     result_type operator()() const

    24     {

    25         list0 a;

    26         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    27     }

    28 

    29     template<class A1> result_type operator()(A1 & a1)

    30     {

    31         list1<A1 &> a(a1);

    32         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    33     }

    34 

    35     template<class A1> result_type operator()(A1 & a1) const

    36     {

    37         list1<A1 &> a(a1);

    38         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    39     }

    40 

    41 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \

    42  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)

    43 

    44     template<class A1> result_type operator()(A1 const & a1)

    45     {

    46         list1<A1 const &> a(a1);

    47         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    48     }

    49 

    50     template<class A1> result_type operator()(A1 const & a1) const

    51     {

    52         list1<A1 const &> a(a1);

    53         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    54     }

    55 

    56 #endif

    57 

    58     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)

    59     {

    60         list2<A1 &, A2 &> a(a1, a2);

    61         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    62     }

    63 

    64     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const

    65     {

    66         list2<A1 &, A2 &> a(a1, a2);

    67         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    68     }

    69 

    70 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \

    71  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)

    72 

    73     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)

    74     {

    75         list2<A1 const &, A2 &> a(a1, a2);

    76         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    77     }

    78 

    79     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const

    80     {

    81         list2<A1 const &, A2 &> a(a1, a2);

    82         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    83     }

    84 

    85 

    86     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)

    87     {

    88         list2<A1 &, A2 const &> a(a1, a2);

    89         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    90     }

    91 

    92     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const

    93     {

    94         list2<A1 &, A2 const &> a(a1, a2);

    95         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

    96     }

    97 

    98 

    99     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)

   100     {

   101         list2<A1 const &, A2 const &> a(a1, a2);

   102         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   103     }

   104 

   105     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const

   106     {

   107         list2<A1 const &, A2 const &> a(a1, a2);

   108         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   109     }

   110 

   111 #endif

   112 

   113     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)

   114     {

   115         list3<A1 &, A2 &, A3 &> a(a1, a2, a3);

   116         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   117     }

   118 

   119     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const

   120     {

   121         list3<A1 &, A2 &, A3 &> a(a1, a2, a3);

   122         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   123     }

   124 

   125     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)

   126     {

   127         list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);

   128         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   129     }

   130 

   131     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const

   132     {

   133         list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);

   134         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   135     }

   136 

   137     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)

   138     {

   139         list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);

   140         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   141     }

   142 

   143     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const

   144     {

   145         list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);

   146         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   147     }

   148 

   149     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)

   150     {

   151         list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);

   152         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   153     }

   154 

   155     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const

   156     {

   157         list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);

   158         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   159     }

   160 

   161     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)

   162     {

   163         list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);

   164         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   165     }

   166 

   167     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const

   168     {

   169         list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);

   170         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   171     }

   172 

   173     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)

   174     {

   175         list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);

   176         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   177     }

   178 

   179     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const

   180     {

   181         list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);

   182         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   183     }

   184 

   185     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)

   186     {

   187         list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);

   188         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   189     }

   190 

   191     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const

   192     {

   193         list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);

   194         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   195     }

   196 

   197     template<class A> result_type eval(A & a)

   198     {

   199         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   200     }

   201 

   202     template<class A> result_type eval(A & a) const

   203     {

   204         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);

   205     }

   206 

   207     template<class V> void accept(V & v) const

   208     {

   209 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )

   210 

   211         using boost::visit_each;

   212 

   213 #endif

   214         BOOST_BIND_VISIT_EACH(v, f_, 0);

   215         l_.accept(v);

   216     }

   217 

   218     bool compare(this_type const & rhs) const

   219     {

   220         return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;

   221     }

   222 

   223 private:

   224 

   225     F f_;

   226     L l_;
test