1// -*- C++ -*- 2 3// Copyright (C) 2005-2020 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 131namespace detail 132{ 133 template<typename Fn, typename Typelist_Chain> 134 struct apply_; 135 136 template<typename Fn, typename Hd, typename Tl> 137 struct apply_<Fn, chain<Hd, Tl> > 138 { 139 void 140 operator()(Fn& f) 141 { 142 f.operator()(Hd()); 143 apply_<Fn, Tl> next; 144 next(f); 145 } 146 }; 147 148 template<typename Fn> 149 struct apply_<Fn, null_type> 150 { 151 void 152 operator()(Fn&) { } 153 }; 154 155 template<typename Gn, typename Typelist_Chain> 156 struct apply_generator1_; 157 158 template<typename Gn, typename Hd, typename Tl> 159 struct apply_generator1_<Gn, chain<Hd, Tl> > 160 { 161 void 162 operator()(Gn& g) 163 { 164 g.template operator()<Hd>(); 165 apply_generator1_<Gn, Tl> next; 166 next(g); 167 } 168 }; 169 170 template<typename Gn> 171 struct apply_generator1_<Gn, null_type> 172 { 173 void 174 operator()(Gn&) { } 175 }; 176 177 template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain> 178 struct apply_generator2_; 179 180 template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV> 181 struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> > 182 { 183 void 184 operator()(Gn& g) 185 { 186 g.template operator()<Hd1, Hd2>(); 187 apply_generator2_<Gn, TlT, TlV> next; 188 next(g); 189 } 190 }; 191 192 template<typename Gn> 193 struct apply_generator2_<Gn, null_type, null_type> 194 { 195 void 196 operator()(Gn&) { } 197 }; 198 199 template<typename Typelist_Chain0, typename Typelist_Chain1> 200 struct append_; 201 202 template<typename Hd, typename Tl, typename Typelist_Chain> 203 struct append_<chain<Hd, Tl>, Typelist_Chain> 204 { 205 private: 206 typedef append_<Tl, Typelist_Chain> append_type; 207 208 public: 209 typedef chain<Hd, typename append_type::type> type; 210 }; 211 212 template<typename Typelist_Chain> 213 struct append_<null_type, Typelist_Chain> 214 { 215 typedef Typelist_Chain type; 216 }; 217 218 template<typename Hd, typename Tl> 219 struct append_<chain<Hd, Tl>, null_type> 220 { 221 typedef chain<Hd, Tl> type; 222 }; 223 224 template<> 225 struct append_<null_type, null_type> 226 { 227 typedef null_type type; 228 }; 229 230 template<typename Typelist_Typelist_Chain> 231 struct append_typelist_; 232 233 template<typename Hd> 234 struct append_typelist_<chain<Hd, null_type> > 235 { 236 typedef chain<Hd, null_type> type; 237 }; 238 239 template<typename Hd, typename Tl> 240 struct append_typelist_<chain< Hd, Tl> > 241 { 242 private: 243 typedef typename append_typelist_<Tl>::type rest_type; 244 245 public: 246 typedef typename append<Hd, node<rest_type> >::type::root type; 247 }; 248 249 template<typename Typelist_Chain, typename T> 250 struct contains_; 251 252 template<typename T> 253 struct contains_<null_type, T> 254 { 255 enum 256 { 257 value = false 258 }; 259 }; 260 261 template<typename Hd, typename Tl, typename T> 262 struct contains_<chain<Hd, Tl>, T> 263 { 264 enum 265 { 266 value = contains_<Tl, T>::value 267 }; 268 }; 269 270 template<typename Tl, typename T> 271 struct contains_<chain<T, Tl>, T> 272 { 273 enum 274 { 275 value = true 276 }; 277 }; 278 279 template<typename Typelist_Chain, template<typename T> class Pred> 280 struct chain_filter_; 281 282 template<template<typename T> class Pred> 283 struct chain_filter_<null_type, Pred> 284 { 285 typedef null_type type; 286 }; 287 288 template<typename Hd, typename Tl, template<typename T> class Pred> 289 struct chain_filter_<chain<Hd, Tl>, Pred> 290 { 291 private: 292 enum 293 { 294 include_hd = Pred<Hd>::value 295 }; 296 297 typedef typename chain_filter_<Tl, Pred>::type rest_type; 298 typedef chain<Hd, rest_type> chain_type; 299 300 public: 301 typedef typename __conditional_type<include_hd, chain_type, rest_type>::__type type; 302 }; 303 304 template<typename Typelist_Chain, int i> 305 struct chain_at_index_; 306 307 template<typename Hd, typename Tl> 308 struct chain_at_index_<chain<Hd, Tl>, 0> 309 { 310 typedef Hd type; 311 }; 312 313 template<typename Hd, typename Tl, int i> 314 struct chain_at_index_<chain<Hd, Tl>, i> 315 { 316 typedef typename chain_at_index_<Tl, i - 1>::type type; 317 }; 318 319 template<class Typelist_Chain, template<typename T> class Transform> 320 struct chain_transform_; 321 322 template<template<typename T> class Transform> 323 struct chain_transform_<null_type, Transform> 324 { 325 typedef null_type type; 326 }; 327 328 template<class Hd, class Tl, template<typename T> class Transform> 329 struct chain_transform_<chain<Hd, Tl>, Transform> 330 { 331 private: 332 typedef typename chain_transform_<Tl, Transform>::type rest_type; 333 typedef typename Transform<Hd>::type transform_type; 334 335 public: 336 typedef chain<transform_type, rest_type> type; 337 }; 338 339 template<typename Typelist_Typelist_Chain> 340 struct chain_flatten_; 341 342 template<typename Hd_Tl> 343 struct chain_flatten_<chain<Hd_Tl, null_type> > 344 { 345 typedef typename Hd_Tl::root type; 346 }; 347 348 template<typename Hd_Typelist, class Tl_Typelist> 349 struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> > 350 { 351 private: 352 typedef typename chain_flatten_<Tl_Typelist>::type rest_type; 353 typedef append<Hd_Typelist, node<rest_type> > append_type; 354 public: 355 typedef typename append_type::type::root type; 356 }; 357} // namespace detail 358 359#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type> 360#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) > 361#define _GLIBCXX_TYPELIST_CHAIN3(X0, X1, X2) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN2(X1, X2) > 362#define _GLIBCXX_TYPELIST_CHAIN4(X0, X1, X2, X3) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN3(X1, X2, X3) > 363#define _GLIBCXX_TYPELIST_CHAIN5(X0, X1, X2, X3, X4) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN4(X1, X2, X3, X4) > 364#define _GLIBCXX_TYPELIST_CHAIN6(X0, X1, X2, X3, X4, X5) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN5(X1, X2, X3, X4, X5) > 365#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) > 366#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) > 367#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) > 368#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) > 369#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) > 370#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) > 371#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) > 372#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) > 373#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) > 374#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) > 375#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) > 376#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) > 377#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) > 378#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) > 379 380 template<typename Fn, typename Typelist> 381 void 382 apply(Fn& fn, Typelist) 383 { 384 detail::apply_<Fn, typename Typelist::root> a; 385 a(fn); 386 } 387 388 template<typename Fn, typename Typelist> 389 void 390 apply_generator(Fn& fn, Typelist) 391 { 392 detail::apply_generator1_<Fn, typename Typelist::root> a; 393 a(fn); 394 } 395 396 template<typename Fn, typename TypelistT, typename TypelistV> 397 void 398 apply_generator(Fn& fn, TypelistT, TypelistV) 399 { 400 typedef typename TypelistT::root rootT; 401 typedef typename TypelistV::root rootV; 402 detail::apply_generator2_<Fn, rootT, rootV> a; 403 a(fn); 404 } 405 406 template<typename Typelist0, typename Typelist1> 407 struct append 408 { 409 private: 410 typedef typename Typelist0::root root0_type; 411 typedef typename Typelist1::root root1_type; 412 typedef detail::append_<root0_type, root1_type> append_type; 413 414 public: 415 typedef node<typename append_type::type> type; 416 }; 417 418 template<typename Typelist_Typelist> 419 struct append_typelist 420 { 421 private: 422 typedef typename Typelist_Typelist::root root_type; 423 typedef detail::append_typelist_<root_type> append_type; 424 425 public: 426 typedef node<typename append_type::type> type; 427 }; 428 429 template<typename Typelist, typename T> 430 struct contains 431 { 432 private: 433 typedef typename Typelist::root root_type; 434 435 public: 436 enum 437 { 438 value = detail::contains_<root_type, T>::value 439 }; 440 }; 441 442 template<typename Typelist, template<typename T> class Pred> 443 struct filter 444 { 445 private: 446 typedef typename Typelist::root root_type; 447 typedef detail::chain_filter_<root_type, Pred> filter_type; 448 449 public: 450 typedef node<typename filter_type::type> type; 451 }; 452 453 template<typename Typelist, int i> 454 struct at_index 455 { 456 private: 457 typedef typename Typelist::root root_type; 458 typedef detail::chain_at_index_<root_type, i> index_type; 459 460 public: 461 typedef typename index_type::type type; 462 }; 463 464 template<typename Typelist, template<typename T> class Transform> 465 struct transform 466 { 467 private: 468 typedef typename Typelist::root root_type; 469 typedef detail::chain_transform_<root_type, Transform> transform_type; 470 471 public: 472 typedef node<typename transform_type::type> type; 473 }; 474 475 template<typename Typelist_Typelist> 476 struct flatten 477 { 478 private: 479 typedef typename Typelist_Typelist::root root_type; 480 typedef typename detail::chain_flatten_<root_type>::type flatten_type; 481 482 public: 483 typedef node<flatten_type> type; 484 }; 485 486 template<typename Typelist> 487 struct from_first 488 { 489 private: 490 typedef typename at_index<Typelist, 0>::type first_type; 491 492 public: 493 typedef node<chain<first_type, null_type> > type; 494 }; 495 496 template<typename T1> 497 struct create1 498 { 499 typedef node<_GLIBCXX_TYPELIST_CHAIN1(T1)> type; 500 }; 501 502 template<typename T1, typename T2> 503 struct create2 504 { 505 typedef node<_GLIBCXX_TYPELIST_CHAIN2(T1,T2)> type; 506 }; 507 508 template<typename T1, typename T2, typename T3> 509 struct create3 510 { 511 typedef node<_GLIBCXX_TYPELIST_CHAIN3(T1,T2,T3)> type; 512 }; 513 514 template<typename T1, typename T2, typename T3, typename T4> 515 struct create4 516 { 517 typedef node<_GLIBCXX_TYPELIST_CHAIN4(T1,T2,T3,T4)> type; 518 }; 519 520 template<typename T1, typename T2, typename T3, 521 typename T4, typename T5> 522 struct create5 523 { 524 typedef node<_GLIBCXX_TYPELIST_CHAIN5(T1,T2,T3,T4,T5)> type; 525 }; 526 527 template<typename T1, typename T2, typename T3, 528 typename T4, typename T5, typename T6> 529 struct create6 530 { 531 typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)> type; 532 }; 533} // namespace typelist 534_GLIBCXX_END_NAMESPACE_VERSION 535} // namespace 536 537 538#endif 539