1// -*- C++ -*- 2 3// Copyright (C) 2005-2015 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. 26 27// Permission to use, copy, modify, sell, and distribute this software 28// is hereby granted without fee, provided that the above copyright 29// notice appears in all copies, and that both that copyright notice and 30// this permission notice appear in supporting documentation. None of 31// the above authors, nor IBM Haifa Research Laboratories, make any 32// representation about the suitability of this software for any 33// purpose. It is provided "as is" without express or implied warranty. 34 35/** 36 * @file ext/typelist.h 37 * This file is a GNU extension to the Standard C++ Library. 38 * 39 * Contains typelist_chain definitions. 40 * Typelists are an idea by Andrei Alexandrescu. 41 */ 42 43#ifndef _TYPELIST_H 44#define _TYPELIST_H 1 45 46#include <ext/type_traits.h> 47 48namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 49{ 50_GLIBCXX_BEGIN_NAMESPACE_VERSION 51 52/** @namespace __gnu_cxx::typelist 53 * @brief GNU typelist extensions for public compile-time use. 54*/ 55namespace typelist 56{ 57 struct null_type { }; 58 59 template<typename Root> 60 struct node 61 { 62 typedef Root root; 63 }; 64 65 // Forward declarations of functors. 66 template<typename Hd, typename Typelist> 67 struct chain 68 { 69 typedef Hd head; 70 typedef Typelist tail; 71 }; 72 73 // Apply all typelist types to unary functor. 74 template<typename Fn, typename Typelist> 75 void 76 apply(Fn&, Typelist); 77 78 /// Apply all typelist types to generator functor. 79 template<typename Gn, typename Typelist> 80 void 81 apply_generator(Gn&, Typelist); 82 83 // Apply all typelist types and values to generator functor. 84 template<typename Gn, typename TypelistT, typename TypelistV> 85 void 86 apply_generator(Gn&, TypelistT, TypelistV); 87 88 template<typename Typelist0, typename Typelist1> 89 struct append; 90 91 template<typename Typelist_Typelist> 92 struct append_typelist; 93 94 template<typename Typelist, typename T> 95 struct contains; 96 97 template<typename Typelist, template<typename T> class Pred> 98 struct filter; 99 100 template<typename Typelist, int i> 101 struct at_index; 102 103 template<typename Typelist, template<typename T> class Transform> 104 struct transform; 105 106 template<typename Typelist_Typelist> 107 struct flatten; 108 109 template<typename Typelist> 110 struct from_first; 111 112 template<typename T1> 113 struct create1; 114 115 template<typename T1, typename T2> 116 struct create2; 117 118 template<typename T1, typename T2, typename T3> 119 struct create3; 120 121 template<typename T1, typename T2, typename T3, typename T4> 122 struct create4; 123 124 template<typename T1, typename T2, typename T3, typename T4, typename T5> 125 struct create5; 126 127 template<typename T1, typename T2, typename T3, 128 typename T4, typename T5, typename T6> 129 struct create6; 130} // namespace typelist 131 132_GLIBCXX_END_NAMESPACE_VERSION 133} // namespace 134 135 136namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 137{ 138_GLIBCXX_BEGIN_NAMESPACE_VERSION 139 140namespace typelist 141{ 142namespace detail 143{ 144 template<typename Fn, typename Typelist_Chain> 145 struct apply_; 146 147 template<typename Fn, typename Hd, typename Tl> 148 struct apply_<Fn, chain<Hd, Tl> > 149 { 150 void 151 operator()(Fn& f) 152 { 153 f.operator()(Hd()); 154 apply_<Fn, Tl> next; 155 next(f); 156 } 157 }; 158 159 template<typename Fn> 160 struct apply_<Fn, null_type> 161 { 162 void 163 operator()(Fn&) { } 164 }; 165 166 template<typename Gn, typename Typelist_Chain> 167 struct apply_generator1_; 168 169 template<typename Gn, typename Hd, typename Tl> 170 struct apply_generator1_<Gn, chain<Hd, Tl> > 171 { 172 void 173 operator()(Gn& g) 174 { 175 g.template operator()<Hd>(); 176 apply_generator1_<Gn, Tl> next; 177 next(g); 178 } 179 }; 180 181 template<typename Gn> 182 struct apply_generator1_<Gn, null_type> 183 { 184 void 185 operator()(Gn&) { } 186 }; 187 188 template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain> 189 struct apply_generator2_; 190 191 template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV> 192 struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> > 193 { 194 void 195 operator()(Gn& g) 196 { 197 g.template operator()<Hd1, Hd2>(); 198 apply_generator2_<Gn, TlT, TlV> next; 199 next(g); 200 } 201 }; 202 203 template<typename Gn> 204 struct apply_generator2_<Gn, null_type, null_type> 205 { 206 void 207 operator()(Gn&) { } 208 }; 209 210 template<typename Typelist_Chain0, typename Typelist_Chain1> 211 struct append_; 212 213 template<typename Hd, typename Tl, typename Typelist_Chain> 214 struct append_<chain<Hd, Tl>, Typelist_Chain> 215 { 216 private: 217 typedef append_<Tl, Typelist_Chain> append_type; 218 219 public: 220 typedef chain<Hd, typename append_type::type> type; 221 }; 222 223 template<typename Typelist_Chain> 224 struct append_<null_type, Typelist_Chain> 225 { 226 typedef Typelist_Chain type; 227 }; 228 229 template<typename Typelist_Chain> 230 struct append_<Typelist_Chain, null_type> 231 { 232 typedef Typelist_Chain type; 233 }; 234 235 template<> 236 struct append_<null_type, null_type> 237 { 238 typedef null_type type; 239 }; 240 241 template<typename Typelist_Typelist_Chain> 242 struct append_typelist_; 243 244 template<typename Hd> 245 struct append_typelist_<chain<Hd, null_type> > 246 { 247 typedef chain<Hd, null_type> type; 248 }; 249 250 template<typename Hd, typename Tl> 251 struct append_typelist_<chain< Hd, Tl> > 252 { 253 private: 254 typedef typename append_typelist_<Tl>::type rest_type; 255 256 public: 257 typedef typename append<Hd, node<rest_type> >::type::root type; 258 }; 259 260 template<typename Typelist_Chain, typename T> 261 struct contains_; 262 263 template<typename T> 264 struct contains_<null_type, T> 265 { 266 enum 267 { 268 value = false 269 }; 270 }; 271 272 template<typename Hd, typename Tl, typename T> 273 struct contains_<chain<Hd, Tl>, T> 274 { 275 enum 276 { 277 value = contains_<Tl, T>::value 278 }; 279 }; 280 281 template<typename Tl, typename T> 282 struct contains_<chain<T, Tl>, T> 283 { 284 enum 285 { 286 value = true 287 }; 288 }; 289 290 template<typename Typelist_Chain, template<typename T> class Pred> 291 struct chain_filter_; 292 293 template<template<typename T> class Pred> 294 struct chain_filter_<null_type, Pred> 295 { 296 typedef null_type type; 297 }; 298 299 template<typename Hd, typename Tl, template<typename T> class Pred> 300 struct chain_filter_<chain<Hd, Tl>, Pred> 301 { 302 private: 303 enum 304 { 305 include_hd = Pred<Hd>::value 306 }; 307 308 typedef typename chain_filter_<Tl, Pred>::type rest_type; 309 typedef chain<Hd, rest_type> chain_type; 310 311 public: 312 typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type; 313 }; 314 315 template<typename Typelist_Chain, int i> 316 struct chain_at_index_; 317 318 template<typename Hd, typename Tl> 319 struct chain_at_index_<chain<Hd, Tl>, 0> 320 { 321 typedef Hd type; 322 }; 323 324 template<typename Hd, typename Tl, int i> 325 struct chain_at_index_<chain<Hd, Tl>, i> 326 { 327 typedef typename chain_at_index_<Tl, i - 1>::type type; 328 }; 329 330 template<class Typelist_Chain, template<typename T> class Transform> 331 struct chain_transform_; 332 333 template<template<typename T> class Transform> 334 struct chain_transform_<null_type, Transform> 335 { 336 typedef null_type type; 337 }; 338 339 template<class Hd, class Tl, template<typename T> class Transform> 340 struct chain_transform_<chain<Hd, Tl>, Transform> 341 { 342 private: 343 typedef typename chain_transform_<Tl, Transform>::type rest_type; 344 typedef typename Transform<Hd>::type transform_type; 345 346 public: 347 typedef chain<transform_type, rest_type> type; 348 }; 349 350 template<typename Typelist_Typelist_Chain> 351 struct chain_flatten_; 352 353 template<typename Hd_Tl> 354 struct chain_flatten_<chain<Hd_Tl, null_type> > 355 { 356 typedef typename Hd_Tl::root type; 357 }; 358 359 template<typename Hd_Typelist, class Tl_Typelist> 360 struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> > 361 { 362 private: 363 typedef typename chain_flatten_<Tl_Typelist>::type rest_type; 364 typedef append<Hd_Typelist, node<rest_type> > append_type; 365 public: 366 typedef typename append_type::type::root type; 367 }; 368} // namespace detail 369} // namespace typelist 370 371_GLIBCXX_END_NAMESPACE_VERSION 372} // namespace 373 374#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type> 375#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) > 376#define _GLIBCXX_TYPELIST_CHAIN3(X0, X1, X2) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN2(X1, X2) > 377#define _GLIBCXX_TYPELIST_CHAIN4(X0, X1, X2, X3) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN3(X1, X2, X3) > 378#define _GLIBCXX_TYPELIST_CHAIN5(X0, X1, X2, X3, X4) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN4(X1, X2, X3, X4) > 379#define _GLIBCXX_TYPELIST_CHAIN6(X0, X1, X2, X3, X4, X5) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN5(X1, X2, X3, X4, X5) > 380#define _GLIBCXX_TYPELIST_CHAIN7(X0, X1, X2, X3, X4, X5, X6) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN6(X1, X2, X3, X4, X5, X6) > 381#define _GLIBCXX_TYPELIST_CHAIN8(X0, X1, X2, X3, X4, X5, X6, X7) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN7(X1, X2, X3, X4, X5, X6, X7) > 382#define _GLIBCXX_TYPELIST_CHAIN9(X0, X1, X2, X3, X4, X5, X6, X7, X8) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN8(X1, X2, X3, X4, X5, X6, X7, X8) > 383#define _GLIBCXX_TYPELIST_CHAIN10(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN9(X1, X2, X3, X4, X5, X6, X7, X8, X9) > 384#define _GLIBCXX_TYPELIST_CHAIN11(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN10(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10) > 385#define _GLIBCXX_TYPELIST_CHAIN12(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN11(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11) > 386#define _GLIBCXX_TYPELIST_CHAIN13(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN12(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12) > 387#define _GLIBCXX_TYPELIST_CHAIN14(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN13(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) > 388#define _GLIBCXX_TYPELIST_CHAIN15(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN14(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) > 389#define _GLIBCXX_TYPELIST_CHAIN16(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN15(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15) > 390#define _GLIBCXX_TYPELIST_CHAIN17(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN16(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16) > 391#define _GLIBCXX_TYPELIST_CHAIN18(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN17(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17) > 392#define _GLIBCXX_TYPELIST_CHAIN19(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN18(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) > 393#define _GLIBCXX_TYPELIST_CHAIN20(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN19(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) > 394 395namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 396{ 397_GLIBCXX_BEGIN_NAMESPACE_VERSION 398 399namespace typelist 400{ 401 template<typename Fn, typename Typelist> 402 void 403 apply(Fn& fn, Typelist) 404 { 405 detail::apply_<Fn, typename Typelist::root> a; 406 a(fn); 407 } 408 409 template<typename Fn, typename Typelist> 410 void 411 apply_generator(Fn& fn, Typelist) 412 { 413 detail::apply_generator1_<Fn, typename Typelist::root> a; 414 a(fn); 415 } 416 417 template<typename Fn, typename TypelistT, typename TypelistV> 418 void 419 apply_generator(Fn& fn, TypelistT, TypelistV) 420 { 421 typedef typename TypelistT::root rootT; 422 typedef typename TypelistV::root rootV; 423 detail::apply_generator2_<Fn, rootT, rootV> a; 424 a(fn); 425 } 426 427 template<typename Typelist0, typename Typelist1> 428 struct append 429 { 430 private: 431 typedef typename Typelist0::root root0_type; 432 typedef typename Typelist1::root root1_type; 433 typedef detail::append_<root0_type, root1_type> append_type; 434 435 public: 436 typedef node<typename append_type::type> type; 437 }; 438 439 template<typename Typelist_Typelist> 440 struct append_typelist 441 { 442 private: 443 typedef typename Typelist_Typelist::root root_type; 444 typedef detail::append_typelist_<root_type> append_type; 445 446 public: 447 typedef node<typename append_type::type> type; 448 }; 449 450 template<typename Typelist, typename T> 451 struct contains 452 { 453 private: 454 typedef typename Typelist::root root_type; 455 456 public: 457 enum 458 { 459 value = detail::contains_<root_type, T>::value 460 }; 461 }; 462 463 template<typename Typelist, template<typename T> class Pred> 464 struct filter 465 { 466 private: 467 typedef typename Typelist::root root_type; 468 typedef detail::chain_filter_<root_type, Pred> filter_type; 469 470 public: 471 typedef node<typename filter_type::type> type; 472 }; 473 474 template<typename Typelist, int i> 475 struct at_index 476 { 477 private: 478 typedef typename Typelist::root root_type; 479 typedef detail::chain_at_index_<root_type, i> index_type; 480 481 public: 482 typedef typename index_type::type type; 483 }; 484 485 template<typename Typelist, template<typename T> class Transform> 486 struct transform 487 { 488 private: 489 typedef typename Typelist::root root_type; 490 typedef detail::chain_transform_<root_type, Transform> transform_type; 491 492 public: 493 typedef node<typename transform_type::type> type; 494 }; 495 496 template<typename Typelist_Typelist> 497 struct flatten 498 { 499 private: 500 typedef typename Typelist_Typelist::root root_type; 501 typedef typename detail::chain_flatten_<root_type>::type flatten_type; 502 503 public: 504 typedef node<flatten_type> type; 505 }; 506 507 template<typename Typelist> 508 struct from_first 509 { 510 private: 511 typedef typename at_index<Typelist, 0>::type first_type; 512 513 public: 514 typedef node<chain<first_type, null_type> > type; 515 }; 516 517 template<typename T1> 518 struct create1 519 { 520 typedef node<_GLIBCXX_TYPELIST_CHAIN1(T1)> type; 521 }; 522 523 template<typename T1, typename T2> 524 struct create2 525 { 526 typedef node<_GLIBCXX_TYPELIST_CHAIN2(T1,T2)> type; 527 }; 528 529 template<typename T1, typename T2, typename T3> 530 struct create3 531 { 532 typedef node<_GLIBCXX_TYPELIST_CHAIN3(T1,T2,T3)> type; 533 }; 534 535 template<typename T1, typename T2, typename T3, typename T4> 536 struct create4 537 { 538 typedef node<_GLIBCXX_TYPELIST_CHAIN4(T1,T2,T3,T4)> type; 539 }; 540 541 template<typename T1, typename T2, typename T3, 542 typename T4, typename T5> 543 struct create5 544 { 545 typedef node<_GLIBCXX_TYPELIST_CHAIN5(T1,T2,T3,T4,T5)> type; 546 }; 547 548 template<typename T1, typename T2, typename T3, 549 typename T4, typename T5, typename T6> 550 struct create6 551 { 552 typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)> type; 553 }; 554} // namespace typelist 555_GLIBCXX_END_NAMESPACE_VERSION 556} // namespace 557 558 559#endif 560