1 /////////////////////////////////////////////////////////////////////////////// 2 /// \file lazy.hpp 3 /// Contains definition of the lazy<> transform. 4 // 5 // Copyright 2008 Eric Niebler. Distributed under the Boost 6 // Software License, Version 1.0. (See accompanying file 7 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8 9 10 11 12 13 14 15 16 template<typename Object > 17 struct lazy<Object()> 18 : transform<lazy<Object()> > 19 { 20 template<typename Expr, typename State, typename Data> 21 struct impl 22 : call< 23 typename make<Object>::template impl<Expr, State, Data>::result_type 24 () 25 >::template impl<Expr, State, Data> 26 {}; 27 }; 28 29 30 31 32 33 34 35 36 template<typename Object , typename A0> 37 struct lazy<Object(A0)> 38 : transform<lazy<Object(A0)> > 39 { 40 template<typename Expr, typename State, typename Data> 41 struct impl 42 : call< 43 typename make<Object>::template impl<Expr, State, Data>::result_type 44 (A0) 45 >::template impl<Expr, State, Data> 46 {}; 47 }; 48 template<typename Object , typename A0> 49 struct lazy<Object(A0...)> 50 : transform<lazy<Object(A0...)> > 51 { 52 template<typename Expr, typename State, typename Data> 53 struct impl 54 : lazy< 55 typename detail::expand_pattern< 56 proto::arity_of<Expr>::value 57 , A0 58 , detail::expand_pattern_rest_0< 59 Object 60 61 > 62 >::type 63 >::template impl<Expr, State, Data> 64 {}; 65 }; 66 67 68 69 70 71 72 73 74 template<typename Object , typename A0 , typename A1> 75 struct lazy<Object(A0 , A1)> 76 : transform<lazy<Object(A0 , A1)> > 77 { 78 template<typename Expr, typename State, typename Data> 79 struct impl 80 : call< 81 typename make<Object>::template impl<Expr, State, Data>::result_type 82 (A0 , A1) 83 >::template impl<Expr, State, Data> 84 {}; 85 }; 86 template<typename Object , typename A0 , typename A1> 87 struct lazy<Object(A0 , A1...)> 88 : transform<lazy<Object(A0 , A1...)> > 89 { 90 template<typename Expr, typename State, typename Data> 91 struct impl 92 : lazy< 93 typename detail::expand_pattern< 94 proto::arity_of<Expr>::value 95 , A1 96 , detail::expand_pattern_rest_1< 97 Object 98 , A0 99 > 100 >::type 101 >::template impl<Expr, State, Data> 102 {}; 103 }; 104 105 106 107 108 109 110 111 112 template<typename Object , typename A0 , typename A1 , typename A2> 113 struct lazy<Object(A0 , A1 , A2)> 114 : transform<lazy<Object(A0 , A1 , A2)> > 115 { 116 template<typename Expr, typename State, typename Data> 117 struct impl 118 : call< 119 typename make<Object>::template impl<Expr, State, Data>::result_type 120 (A0 , A1 , A2) 121 >::template impl<Expr, State, Data> 122 {}; 123 }; 124 template<typename Object , typename A0 , typename A1 , typename A2> 125 struct lazy<Object(A0 , A1 , A2...)> 126 : transform<lazy<Object(A0 , A1 , A2...)> > 127 { 128 template<typename Expr, typename State, typename Data> 129 struct impl 130 : lazy< 131 typename detail::expand_pattern< 132 proto::arity_of<Expr>::value 133 , A2 134 , detail::expand_pattern_rest_2< 135 Object 136 , A0 , A1 137 > 138 >::type 139 >::template impl<Expr, State, Data> 140 {}; 141 }; 142 143 144 145 146 147 148 149 150 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> 151 struct lazy<Object(A0 , A1 , A2 , A3)> 152 : transform<lazy<Object(A0 , A1 , A2 , A3)> > 153 { 154 template<typename Expr, typename State, typename Data> 155 struct impl 156 : call< 157 typename make<Object>::template impl<Expr, State, Data>::result_type 158 (A0 , A1 , A2 , A3) 159 >::template impl<Expr, State, Data> 160 {}; 161 }; 162 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> 163 struct lazy<Object(A0 , A1 , A2 , A3...)> 164 : transform<lazy<Object(A0 , A1 , A2 , A3...)> > 165 { 166 template<typename Expr, typename State, typename Data> 167 struct impl 168 : lazy< 169 typename detail::expand_pattern< 170 proto::arity_of<Expr>::value 171 , A3 172 , detail::expand_pattern_rest_3< 173 Object 174 , A0 , A1 , A2 175 > 176 >::type 177 >::template impl<Expr, State, Data> 178 {}; 179 }; 180 181 182 183 184 185 186 187 188 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 189 struct lazy<Object(A0 , A1 , A2 , A3 , A4)> 190 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> > 191 { 192 template<typename Expr, typename State, typename Data> 193 struct impl 194 : call< 195 typename make<Object>::template impl<Expr, State, Data>::result_type 196 (A0 , A1 , A2 , A3 , A4) 197 >::template impl<Expr, State, Data> 198 {}; 199 }; 200 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 201 struct lazy<Object(A0 , A1 , A2 , A3 , A4...)> 202 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> > 203 { 204 template<typename Expr, typename State, typename Data> 205 struct impl 206 : lazy< 207 typename detail::expand_pattern< 208 proto::arity_of<Expr>::value 209 , A4 210 , detail::expand_pattern_rest_4< 211 Object 212 , A0 , A1 , A2 , A3 213 > 214 >::type 215 >::template impl<Expr, State, Data> 216 {}; 217 }; 218 219 220 221 222 223 224 225 226 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 227 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> 228 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> > 229 { 230 template<typename Expr, typename State, typename Data> 231 struct impl 232 : call< 233 typename make<Object>::template impl<Expr, State, Data>::result_type 234 (A0 , A1 , A2 , A3 , A4 , A5) 235 >::template impl<Expr, State, Data> 236 {}; 237 }; 238 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 239 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> 240 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > 241 { 242 template<typename Expr, typename State, typename Data> 243 struct impl 244 : lazy< 245 typename detail::expand_pattern< 246 proto::arity_of<Expr>::value 247 , A5 248 , detail::expand_pattern_rest_5< 249 Object 250 , A0 , A1 , A2 , A3 , A4 251 > 252 >::type 253 >::template impl<Expr, State, Data> 254 {}; 255 }; 256 257 258 259 260 261 262 263 264 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 265 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> 266 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > 267 { 268 template<typename Expr, typename State, typename Data> 269 struct impl 270 : call< 271 typename make<Object>::template impl<Expr, State, Data>::result_type 272 (A0 , A1 , A2 , A3 , A4 , A5 , A6) 273 >::template impl<Expr, State, Data> 274 {}; 275 }; 276 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 277 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> 278 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > 279 { 280 template<typename Expr, typename State, typename Data> 281 struct impl 282 : lazy< 283 typename detail::expand_pattern< 284 proto::arity_of<Expr>::value 285 , A6 286 , detail::expand_pattern_rest_6< 287 Object 288 , A0 , A1 , A2 , A3 , A4 , A5 289 > 290 >::type 291 >::template impl<Expr, State, Data> 292 {}; 293 }; 294 295 296 297 298 299 300 301 302 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 303 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> 304 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > 305 { 306 template<typename Expr, typename State, typename Data> 307 struct impl 308 : call< 309 typename make<Object>::template impl<Expr, State, Data>::result_type 310 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) 311 >::template impl<Expr, State, Data> 312 {}; 313 }; 314 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 315 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> 316 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > 317 { 318 template<typename Expr, typename State, typename Data> 319 struct impl 320 : lazy< 321 typename detail::expand_pattern< 322 proto::arity_of<Expr>::value 323 , A7 324 , detail::expand_pattern_rest_7< 325 Object 326 , A0 , A1 , A2 , A3 , A4 , A5 , A6 327 > 328 >::type 329 >::template impl<Expr, State, Data> 330 {}; 331 }; 332 333 334 335 336 337 338 339 340 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 341 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> 342 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > 343 { 344 template<typename Expr, typename State, typename Data> 345 struct impl 346 : call< 347 typename make<Object>::template impl<Expr, State, Data>::result_type 348 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) 349 >::template impl<Expr, State, Data> 350 {}; 351 }; 352 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 353 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> 354 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > 355 { 356 template<typename Expr, typename State, typename Data> 357 struct impl 358 : lazy< 359 typename detail::expand_pattern< 360 proto::arity_of<Expr>::value 361 , A8 362 , detail::expand_pattern_rest_8< 363 Object 364 , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 365 > 366 >::type 367 >::template impl<Expr, State, Data> 368 {}; 369 }; 370 371 372 373 374 375 376 377 378 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> 379 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> 380 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > 381 { 382 template<typename Expr, typename State, typename Data> 383 struct impl 384 : call< 385 typename make<Object>::template impl<Expr, State, Data>::result_type 386 (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) 387 >::template impl<Expr, State, Data> 388 {}; 389 }; 390 template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> 391 struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> 392 : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > 393 { 394 template<typename Expr, typename State, typename Data> 395 struct impl 396 : lazy< 397 typename detail::expand_pattern< 398 proto::arity_of<Expr>::value 399 , A9 400 , detail::expand_pattern_rest_9< 401 Object 402 , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 403 > 404 >::type 405 >::template impl<Expr, State, Data> 406 {}; 407 }; 408