modules_mobile/core/include/dpl/3rdparty/fastdelegate/FastDelegateBind.h

   1 //                                              FastDelegateBind.h \r
   2 //  Helper file for FastDelegates. Provides bind() function, enabling\r
   3 //  FastDelegates to be rapidly compared to programs using boost::function and boost::bind.\r
   4 //\r
   5 //  Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp\r
   6 //\r
   7 //              Original author: Jody Hagins.\r
   8 //               Minor changes by Don Clugston.\r
   9 //\r
  10 // Warning: The arguments to 'bind' are ignored! No actual binding is performed.\r
  11 // The behaviour is equivalent to boost::bind only when the basic placeholder \r
  12 // arguments _1, _2, _3, etc are used in order.\r
  13 //\r
  14 // HISTORY:\r
  15 //      1.4 Dec 2004. Initial release as part of FastDelegate 1.4.\r
  16 \r
  17 \r
  18 #ifndef FASTDELEGATEBIND_H\r
  19 #define FASTDELEGATEBIND_H\r
  20 #if _MSC_VER > 1000\r
  21 #pragma once\r
  22 #endif // _MSC_VER > 1000\r
  23 \r
  24 ////////////////////////////////////////////////////////////////////////////////\r
  25 //                                              FastDelegate bind()\r
  26 //\r
  27 //                              bind() helper function for boost compatibility.\r
  28 //                              (Original author: Jody Hagins).\r
  29 //\r
  30 // Add another helper, so FastDelegate can be a dropin replacement\r
  31 // for boost::bind (in a fair number of cases).\r
  32 // Note the elipses, because boost::bind() takes place holders\r
  33 // but FastDelegate does not care about them.  Getting the place holder\r
  34 // mechanism to work, and play well with boost is a bit tricky, so\r
  35 // we do the "easy" thing...\r
  36 // Assume we have the following code...\r
  37 //      using boost::bind;\r
  38 //      bind(&Foo:func, &foo, _1, _2);\r
  39 // we should be able to replace the "using" with...\r
  40 //      using fastdelegate::bind;\r
  41 // and everything should work fine...\r
  42 ////////////////////////////////////////////////////////////////////////////////\r
  43 \r
  44 #ifdef FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX\r
  45 \r
  46 namespace fastdelegate {\r
  47 \r
  48 //N=0\r
  49 template <class X, class Y, class RetType>\r
  50 FastDelegate< RetType (  ) >\r
  51 bind(\r
  52     RetType (X::*func)(  ),\r
  53     Y * y,\r
  54     ...)\r
  55 { \r
  56   return FastDelegate< RetType (  ) >(y, func);\r
  57 }\r
  58 \r
  59 template <class X, class Y, class RetType>\r
  60 FastDelegate< RetType (  ) >\r
  61 bind(\r
  62     RetType (X::*func)(  ) const,\r
  63     Y * y,\r
  64     ...)\r
  65 { \r
  66   return FastDelegate< RetType (  ) >(y, func);\r
  67 }\r
  68 \r
  69 //N=1\r
  70 template <class X, class Y, class RetType, class Param1>\r
  71 FastDelegate< RetType ( Param1 p1 ) >\r
  72 bind(\r
  73     RetType (X::*func)( Param1 p1 ),\r
  74     Y * y,\r
  75     ...)\r
  76 { \r
  77   return FastDelegate< RetType ( Param1 p1 ) >(y, func);\r
  78 }\r
  79 \r
  80 template <class X, class Y, class RetType, class Param1>\r
  81 FastDelegate< RetType ( Param1 p1 ) >\r
  82 bind(\r
  83     RetType (X::*func)( Param1 p1 ) const,\r
  84     Y * y,\r
  85     ...)\r
  86 { \r
  87   return FastDelegate< RetType ( Param1 p1 ) >(y, func);\r
  88 }\r
  89 \r
  90 //N=2\r
  91 template <class X, class Y, class RetType, class Param1, class Param2>\r
  92 FastDelegate< RetType ( Param1 p1, Param2 p2 ) >\r
  93 bind(\r
  94     RetType (X::*func)( Param1 p1, Param2 p2 ),\r
  95     Y * y,\r
  96     ...)\r
  97 { \r
  98   return FastDelegate< RetType ( Param1 p1, Param2 p2 ) >(y, func);\r
  99 }\r
 100 \r
 101 template <class X, class Y, class RetType, class Param1, class Param2>\r
 102 FastDelegate< RetType ( Param1 p1, Param2 p2 ) >\r
 103 bind(\r
 104     RetType (X::*func)( Param1 p1, Param2 p2 ) const,\r
 105     Y * y,\r
 106     ...)\r
 107 { \r
 108   return FastDelegate< RetType ( Param1 p1, Param2 p2 ) >(y, func);\r
 109 }\r
 110 \r
 111 //N=3\r
 112 template <class X, class Y, class RetType, class Param1, class Param2, class Param3>\r
 113 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3 ) >\r
 114 bind(\r
 115     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3 ),\r
 116     Y * y,\r
 117     ...)\r
 118 { \r
 119   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3 ) >(y, func);\r
 120 }\r
 121 \r
 122 template <class X, class Y, class RetType, class Param1, class Param2, class Param3>\r
 123 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3 ) >\r
 124 bind(\r
 125     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3 ) const,\r
 126     Y * y,\r
 127     ...)\r
 128 { \r
 129   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3 ) >(y, func);\r
 130 }\r
 131 \r
 132 //N=4\r
 133 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>\r
 134 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) >\r
 135 bind(\r
 136     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ),\r
 137     Y * y,\r
 138     ...)\r
 139 { \r
 140   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) >(y, func);\r
 141 }\r
 142 \r
 143 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>\r
 144 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) >\r
 145 bind(\r
 146     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) const,\r
 147     Y * y,\r
 148     ...)\r
 149 { \r
 150   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4 ) >(y, func);\r
 151 }\r
 152 \r
 153 //N=5\r
 154 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>\r
 155 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) >\r
 156 bind(\r
 157     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ),\r
 158     Y * y,\r
 159     ...)\r
 160 { \r
 161   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) >(y, func);\r
 162 }\r
 163 \r
 164 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>\r
 165 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) >\r
 166 bind(\r
 167     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) const,\r
 168     Y * y,\r
 169     ...)\r
 170 { \r
 171   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5 ) >(y, func);\r
 172 }\r
 173 \r
 174 //N=6\r
 175 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>\r
 176 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) >\r
 177 bind(\r
 178     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ),\r
 179     Y * y,\r
 180     ...)\r
 181 { \r
 182   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) >(y, func);\r
 183 }\r
 184 \r
 185 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>\r
 186 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) >\r
 187 bind(\r
 188     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) const,\r
 189     Y * y,\r
 190     ...)\r
 191 { \r
 192   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6 ) >(y, func);\r
 193 }\r
 194 \r
 195 //N=7\r
 196 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>\r
 197 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) >\r
 198 bind(\r
 199     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ),\r
 200     Y * y,\r
 201     ...)\r
 202 { \r
 203   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) >(y, func);\r
 204 }\r
 205 \r
 206 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>\r
 207 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) >\r
 208 bind(\r
 209     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) const,\r
 210     Y * y,\r
 211     ...)\r
 212 { \r
 213   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7 ) >(y, func);\r
 214 }\r
 215 \r
 216 //N=8\r
 217 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>\r
 218 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) >\r
 219 bind(\r
 220     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ),\r
 221     Y * y,\r
 222     ...)\r
 223 { \r
 224   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) >(y, func);\r
 225 }\r
 226 \r
 227 template <class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>\r
 228 FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) >\r
 229 bind(\r
 230     RetType (X::*func)( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) const,\r
 231     Y * y,\r
 232     ...)\r
 233 { \r
 234   return FastDelegate< RetType ( Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8 ) >(y, func);\r
 235 }\r
 236 \r
 237 \r
 238 #endif //FASTDELEGATE_ALLOW_FUNCTION_TYPE_SYNTAX\r
 239 \r
 240 } // namespace fastdelegate\r
 241 \r
 242 #endif // !defined(FASTDELEGATEBIND_H)\r
 243 \r