/src/contrib/boost/spirit/home/phoenix/statement/switch.hpp

http://pythonocc.googlecode.com/ · C++ Header · 151 lines · 125 code · 20 blank · 6 comment · 0 complexity · ccbeefb80f4df818395ca302f88d8dbe MD5 · raw file

  1. /*=============================================================================
  2. Copyright (c) 2001-2007 Joel de Guzman
  3. Distributed under the Boost Software License, Version 1.0. (See accompanying
  4. file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5. ==============================================================================*/
  6. #ifndef PHOENIX_STATEMENT_SWITCH_HPP
  7. #define PHOENIX_STATEMENT_SWITCH_HPP
  8. #include <boost/spirit/home/phoenix/core/composite.hpp>
  9. #include <boost/spirit/home/phoenix/core/compose.hpp>
  10. #include <boost/spirit/home/phoenix/core/nothing.hpp>
  11. #include <boost/spirit/home/phoenix/statement/detail/switch_eval.hpp>
  12. #include <boost/spirit/home/phoenix/statement/detail/switch.hpp>
  13. #include <boost/utility/enable_if.hpp>
  14. #include <boost/mpl/not.hpp>
  15. namespace boost { namespace phoenix
  16. {
  17. template <typename Derived, typename Actor>
  18. struct switch_case_base
  19. {
  20. typedef Derived derived_t;
  21. typedef Actor actor_t;
  22. typedef typename Actor::no_nullary no_nullary;
  23. template <typename Env>
  24. struct result
  25. {
  26. typedef typename Actor::eval_type::template result<Env>::type type;
  27. };
  28. switch_case_base(Actor const& actor)
  29. : actor(actor) {}
  30. template <typename Env>
  31. typename result<Env>::type
  32. eval(Env const& env) const
  33. {
  34. return actor.eval(env);
  35. }
  36. Actor actor;
  37. };
  38. template <typename Actor, typename K, K Value>
  39. struct switch_case : switch_case_base<switch_case<Actor, K, Value>, Actor>
  40. {
  41. typedef switch_case_base<switch_case<Actor, K, Value>, Actor> base_t;
  42. static K const value = Value;
  43. static bool const is_default = false;
  44. switch_case(Actor const& actor)
  45. : base_t(actor) {}
  46. };
  47. template <typename Actor>
  48. struct default_case : switch_case_base<default_case<Actor>, Actor>
  49. {
  50. typedef switch_case_base<default_case<Actor>, Actor> base_t;
  51. static bool const is_default = true;
  52. default_case(Actor const& actor)
  53. : base_t(actor) {}
  54. };
  55. template <typename Cond>
  56. struct switch_gen
  57. {
  58. switch_gen(Cond const& cond)
  59. : cond(cond) {}
  60. template <typename Cases>
  61. typename lazy_enable_if<
  62. fusion::traits::is_sequence<Cases>
  63. , detail::switch_composite_actor<Cond, Cases>
  64. >::type
  65. operator[](Cases const& cases) const
  66. {
  67. typedef typename
  68. detail::switch_composite<Cond, Cases>
  69. switch_composite;
  70. return switch_composite::eval(cond, cases);
  71. }
  72. template <typename D, typename A>
  73. actor<typename detail::
  74. switch_composite<Cond, fusion::vector<actor<D> > >::type>
  75. operator[](switch_case_base<D, A> const& case_) const
  76. {
  77. typedef typename
  78. detail::switch_composite<Cond, fusion::vector<actor<D> > >
  79. switch_composite;
  80. return switch_composite::eval(cond,
  81. fusion::vector<actor<D> >(static_cast<D const&>(case_)));
  82. }
  83. Cond cond;
  84. };
  85. template <typename Cond>
  86. inline switch_gen<typename as_actor<Cond>::type>
  87. switch_(Cond const& cond)
  88. {
  89. return switch_gen<typename as_actor<Cond>::type>(
  90. as_actor<Cond>::convert(cond));
  91. }
  92. template <int N, typename A0>
  93. switch_case<typename as_actor<A0>::type, int, N>
  94. case_(A0 const& _0)
  95. {
  96. return switch_case<typename as_actor<A0>::type, int, N>
  97. (as_actor<A0>::convert(_0));
  98. }
  99. template <typename A0>
  100. default_case<typename as_actor<A0>::type>
  101. default_(A0 const& _0)
  102. {
  103. return default_case<typename as_actor<A0>::type>
  104. (as_actor<A0>::convert(_0));
  105. }
  106. template <typename D0, typename A0, typename D1, typename A1>
  107. inline typename detail::compose_case_a<D0, D1>::type
  108. operator,(
  109. switch_case_base<D0, A0> const& _0
  110. , switch_case_base<D1, A1> const& _1
  111. )
  112. {
  113. return detail::compose_case_a<D0, D1>::eval(
  114. static_cast<D0 const&>(_0)
  115. , static_cast<D1 const&>(_1)
  116. );
  117. }
  118. template <typename Seq, typename D, typename A>
  119. inline typename
  120. lazy_enable_if<
  121. fusion::traits::is_sequence<Seq>
  122. , detail::compose_case_b<Seq, D>
  123. >::type
  124. operator,(Seq const& seq, switch_case_base<D, A> const& case_)
  125. {
  126. return detail::compose_case_b<Seq, D>::eval(
  127. seq, static_cast<D const&>(case_));
  128. }
  129. }}
  130. #endif