MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/ossrv_pub/boost_apis/boost/bind/make_adaptable.hpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED

     2 #define BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED

     3 

     4 //

     5 //  make_adaptable.hpp

     6 //

     7 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.

     8 //

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

    10 // accompanying file LICENSE_1_0.txt or copy at

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

    12 //

    13 

    14 namespace boost

    15 {

    16 

    17 namespace _bi

    18 {

    19 

    20 template<class R, class F> class af0

    21 {

    22 public:

    23 

    24     typedef R result_type;

    25 

    26     explicit af0(F f): f_(f)

    27     {

    28     }

    29 

    30     result_type operator()()

    31     {

    32         return f_();

    33     }

    34 

    35     result_type operator()() const

    36     {

    37         return f_();

    38     }

    39 

    40 private:

    41 

    42     F f_;

    43 };

    44 

    45 template<class R, class A1, class F> class af1

    46 {

    47 public:

    48 

    49     typedef R result_type;

    50     typedef A1 argument_type;

    51     typedef A1 arg1_type;

    52 

    53     explicit af1(F f): f_(f)

    54     {

    55     }

    56 

    57     result_type operator()(A1 a1)

    58     {

    59         return f_(a1);

    60     }

    61 

    62     result_type operator()(A1 a1) const

    63     {

    64         return f_(a1);

    65     }

    66 

    67 private:

    68 

    69     F f_;

    70 };

    71 

    72 template<class R, class A1, class A2, class F> class af2

    73 {

    74 public:

    75 

    76     typedef R result_type;

    77     typedef A1 first_argument_type;

    78     typedef A2 second_argument_type;

    79     typedef A1 arg1_type;

    80     typedef A2 arg2_type;

    81 

    82     explicit af2(F f): f_(f)

    83     {

    84     }

    85 

    86     result_type operator()(A1 a1, A2 a2)

    87     {

    88         return f_(a1, a2);

    89     }

    90 

    91     result_type operator()(A1 a1, A2 a2) const

    92     {

    93         return f_(a1, a2);

    94     }

    95 

    96 private:

    97 

    98     F f_;

    99 };

   100 

   101 template<class R, class A1, class A2, class A3, class F> class af3

   102 {

   103 public:

   104 

   105     typedef R result_type;

   106     typedef A1 arg1_type;

   107     typedef A2 arg2_type;

   108     typedef A3 arg3_type;

   109 

   110     explicit af3(F f): f_(f)

   111     {

   112     }

   113 

   114     result_type operator()(A1 a1, A2 a2, A3 a3)

   115     {

   116         return f_(a1, a2, a3);

   117     }

   118 

   119     result_type operator()(A1 a1, A2 a2, A3 a3) const

   120     {

   121         return f_(a1, a2, a3);

   122     }

   123 

   124 private:

   125 

   126     F f_;

   127 };

   128 

   129 template<class R, class A1, class A2, class A3, class A4, class F> class af4

   130 {

   131 public:

   132 

   133     typedef R result_type;

   134     typedef A1 arg1_type;

   135     typedef A2 arg2_type;

   136     typedef A3 arg3_type;

   137     typedef A4 arg4_type;

   138 

   139     explicit af4(F f): f_(f)

   140     {

   141     }

   142 

   143     result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4)

   144     {

   145         return f_(a1, a2, a3, a4);

   146     }

   147 

   148     result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const

   149     {

   150         return f_(a1, a2, a3, a4);

   151     }

   152 

   153 private:

   154 

   155     F f_;

   156 };

   157 

   158 } // namespace _bi

   159 

   160 template<class R, class F> _bi::af0<R, F> make_adaptable(F f)

   161 {

   162     return _bi::af0<R, F>(f);

   163 }

   164 

   165 template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)

   166 {

   167     return _bi::af1<R, A1, F>(f);

   168 }

   169 

   170 template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)

   171 {

   172     return _bi::af2<R, A1, A2, F>(f);

   173 }

   174 

   175 template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)

   176 {

   177     return _bi::af3<R, A1, A2, A3, F>(f);

   178 }

   179 

   180 template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)

   181 {

   182     return _bi::af4<R, A1, A2, A3, A4, F>(f);

   183 }

   184 

   185 } // namespace boost

   186 

   187 #endif // #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
Symaptic