stc/exp/ml_stc_linux_make_v1.0/include/boost/bind/protect.hpp

   1 #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED\r
   2 #define BOOST_BIND_PROTECT_HPP_INCLUDED\r
   3 \r
   4 //\r
   5 //  protect.hpp\r
   6 //\r
   7 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.\r
   8 //  Copyright (c) 2009 Steven Watanabe\r
   9 //\r
  10 // Distributed under the Boost Software License, Version 1.0. (See\r
  11 // accompanying file LICENSE_1_0.txt or copy at\r
  12 // http://www.boost.org/LICENSE_1_0.txt)\r
  13 //\r
  14 \r
  15 #include <boost/config.hpp>\r
  16 #include <boost/detail/workaround.hpp>\r
  17 \r
  18 namespace boost\r
  19 {\r
  20 \r
  21 namespace _bi\r
  22 {\r
  23 \r
  24 template<class F> class protected_bind_t\r
  25 {\r
  26 public:\r
  27 \r
  28     typedef typename F::result_type result_type;\r
  29 \r
  30     explicit protected_bind_t(F f): f_(f)\r
  31     {\r
  32     }\r
  33 \r
  34     result_type operator()()\r
  35     {\r
  36         return f_();\r
  37     }\r
  38 \r
  39     result_type operator()() const\r
  40     {\r
  41         return f_();\r
  42     }\r
  43 \r
  44     template<class A1> result_type operator()(A1 & a1)\r
  45     {\r
  46         return f_(a1);\r
  47     }\r
  48 \r
  49     template<class A1> result_type operator()(A1 & a1) const\r
  50     {\r
  51         return f_(a1);\r
  52     }\r
  53 \r
  54 \r
  55 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
  56  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
  57 \r
  58     template<class A1> result_type operator()(const A1 & a1)\r
  59     {\r
  60         return f_(a1);\r
  61     }\r
  62 \r
  63     template<class A1> result_type operator()(const A1 & a1) const\r
  64     {\r
  65         return f_(a1);\r
  66     }\r
  67 \r
  68 #endif\r
  69 \r
  70     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)\r
  71     {\r
  72         return f_(a1, a2);\r
  73     }\r
  74 \r
  75     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const\r
  76     {\r
  77         return f_(a1, a2);\r
  78     }\r
  79 \r
  80 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
  81  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
  82 \r
  83     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)\r
  84     {\r
  85         return f_(a1, a2);\r
  86     }\r
  87 \r
  88     template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const\r
  89     {\r
  90         return f_(a1, a2);\r
  91     }\r
  92 \r
  93     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)\r
  94     {\r
  95         return f_(a1, a2);\r
  96     }\r
  97 \r
  98     template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const\r
  99     {\r
 100         return f_(a1, a2);\r
 101     }\r
 102 \r
 103     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)\r
 104     {\r
 105         return f_(a1, a2);\r
 106     }\r
 107 \r
 108     template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const\r
 109     {\r
 110         return f_(a1, a2);\r
 111     }\r
 112 \r
 113 #endif\r
 114 \r
 115     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)\r
 116     {\r
 117         return f_(a1, a2, a3);\r
 118     }\r
 119 \r
 120     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const\r
 121     {\r
 122         return f_(a1, a2, a3);\r
 123     }\r
 124     \r
 125 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 126  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 127 \r
 128     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)\r
 129     {\r
 130         return f_(a1, a2, a3);\r
 131     }\r
 132 \r
 133     template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const\r
 134     {\r
 135         return f_(a1, a2, a3);\r
 136     }\r
 137     \r
 138 #endif\r
 139 \r
 140     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)\r
 141     {\r
 142         return f_(a1, a2, a3, a4);\r
 143     }\r
 144 \r
 145     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const\r
 146     {\r
 147         return f_(a1, a2, a3, a4);\r
 148     }\r
 149     \r
 150 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 151  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 152 \r
 153     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)\r
 154     {\r
 155         return f_(a1, a2, a3, a4);\r
 156     }\r
 157 \r
 158     template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const\r
 159     {\r
 160         return f_(a1, a2, a3, a4);\r
 161     }\r
 162 \r
 163 #endif\r
 164 \r
 165     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)\r
 166     {\r
 167         return f_(a1, a2, a3, a4, a5);\r
 168     }\r
 169 \r
 170     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\r
 171     {\r
 172         return f_(a1, a2, a3, a4, a5);\r
 173     }\r
 174     \r
 175 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 176  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 177 \r
 178     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)\r
 179     {\r
 180         return f_(a1, a2, a3, a4, a5);\r
 181     }\r
 182 \r
 183     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const\r
 184     {\r
 185         return f_(a1, a2, a3, a4, a5);\r
 186     }\r
 187 \r
 188 #endif\r
 189 \r
 190     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)\r
 191     {\r
 192         return f_(a1, a2, a3, a4, a5, a6);\r
 193     }\r
 194 \r
 195     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\r
 196     {\r
 197         return f_(a1, a2, a3, a4, a5, a6);\r
 198     }\r
 199     \r
 200 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 201  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 202 \r
 203     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)\r
 204     {\r
 205         return f_(a1, a2, a3, a4, a5, a6);\r
 206     }\r
 207 \r
 208     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const\r
 209     {\r
 210         return f_(a1, a2, a3, a4, a5, a6);\r
 211     }\r
 212 \r
 213 #endif\r
 214 \r
 215     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)\r
 216     {\r
 217         return f_(a1, a2, a3, a4, a5, a6, a7);\r
 218     }\r
 219 \r
 220     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\r
 221     {\r
 222         return f_(a1, a2, a3, a4, a5, a6, a7);\r
 223     }\r
 224     \r
 225 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 226  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 227 \r
 228     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)\r
 229     {\r
 230         return f_(a1, a2, a3, a4, a5, a6, a7);\r
 231     }\r
 232 \r
 233     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const\r
 234     {\r
 235         return f_(a1, a2, a3, a4, a5, a6, a7);\r
 236     }\r
 237 \r
 238 #endif\r
 239 \r
 240     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)\r
 241     {\r
 242         return f_(a1, a2, a3, a4, a5, a6, a7, a8);\r
 243     }\r
 244 \r
 245     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\r
 246     {\r
 247         return f_(a1, a2, a3, a4, a5, a6, a7, a8);\r
 248     }\r
 249     \r
 250 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 251  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 252 \r
 253     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)\r
 254     {\r
 255         return f_(a1, a2, a3, a4, a5, a6, a7, a8);\r
 256     }\r
 257 \r
 258     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const\r
 259     {\r
 260         return f_(a1, a2, a3, a4, a5, a6, a7, a8);\r
 261     }\r
 262 \r
 263 #endif\r
 264 \r
 265     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)\r
 266     {\r
 267         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);\r
 268     }\r
 269 \r
 270     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\r
 271     {\r
 272         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);\r
 273     }\r
 274     \r
 275 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \\r
 276  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)\r
 277 \r
 278     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)\r
 279     {\r
 280         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);\r
 281     }\r
 282 \r
 283     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const\r
 284     {\r
 285         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);\r
 286     }\r
 287 \r
 288 #endif\r
 289 \r
 290 private:\r
 291 \r
 292     F f_;\r
 293 };\r
 294 \r
 295 } // namespace _bi\r
 296 \r
 297 template<class F> _bi::protected_bind_t<F> protect(F f)\r
 298 {\r
 299     return _bi::protected_bind_t<F>(f);\r
 300 }\r
 301 \r
 302 } // namespace boost\r
 303 \r
 304 #endif // #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED\r