ceph/src/boost/libs/hana/test/map/cnstr.variadic.cpp

   1 // Copyright Louis Dionne 2013-2017
   2 // Distributed under the Boost Software License, Version 1.0.
   3 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
   4
   5 #include <boost/hana/assert.hpp>
   6 #include <boost/hana/at_key.hpp>
   7 #include <boost/hana/equal.hpp>
   8 #include <boost/hana/map.hpp>
   9 #include <boost/hana/pair.hpp>
  10
  11 #include <laws/base.hpp>
  12 #include <support/constexpr_move_only.hpp>
  13 #include <support/minimal_product.hpp>
  14 #include <support/tracked_move_only.hpp>
  15
  16 #include <string>
  17 #include <vector>
  18 namespace hana = boost::hana;
  19
  20
  21 template <int i>
  22 using pair = ::product_t<hana::test::ct_eq<i>, hana::test::ct_eq<-i>>;
  23
  24 // Check with move-only literal types.
  25 constexpr bool in_constexpr_context() {
  26     hana::map<hana::pair<ConstexprMoveOnly<2>, ConstexprMoveOnly<20>>,
  27               hana::pair<ConstexprMoveOnly<3>, ConstexprMoveOnly<30>>> map{
  28         hana::make_pair(ConstexprMoveOnly<2>{}, ConstexprMoveOnly<20>{}),
  29         hana::make_pair(ConstexprMoveOnly<3>{}, ConstexprMoveOnly<30>{})
  30     };
  31     return true;
  32 }
  33
  34 static_assert(in_constexpr_context(), "");
  35
  36 int main() {
  37     // Basic check with non trivial runtime state
  38     {
  39         std::vector<std::string> v{"Hello", "world", "!"};
  40
  41         hana::map<
  42             hana::pair<hana::test::ct_eq<1>, std::string>,
  43             hana::pair<hana::test::ct_eq<2>, std::vector<std::string>>
  44         > map{
  45             hana::make_pair(hana::test::ct_eq<1>{}, std::string{"Hello world!"}),
  46             hana::make_pair(hana::test::ct_eq<2>{}, v)
  47         };
  48
  49         BOOST_HANA_RUNTIME_CHECK(
  50             hana::at_key(map, hana::test::ct_eq<1>{}) == std::string{"Hello world!"}
  51         );
  52
  53         BOOST_HANA_RUNTIME_CHECK(
  54             hana::at_key(map, hana::test::ct_eq<2>{}) == v
  55         );
  56     }
  57
  58     {
  59         hana::map<> map{};
  60         BOOST_HANA_CONSTANT_CHECK(hana::equal(
  61             map,
  62             hana::make_map()
  63         ));
  64     }
  65
  66     {
  67         hana::map<pair<0>> map{pair<0>{}};
  68         BOOST_HANA_CONSTANT_CHECK(hana::equal(
  69             map,
  70             hana::make_map(pair<0>{})
  71         ));
  72     }
  73
  74     {
  75         hana::map<pair<0>, pair<1>> map{pair<0>{}, pair<1>{}};
  76         BOOST_HANA_CONSTANT_CHECK(hana::equal(
  77             map,
  78             hana::make_map(pair<0>{}, pair<1>{})
  79         ));
  80     }
  81
  82     {
  83         hana::map<pair<0>, pair<1>, pair<2>> map{pair<0>{}, pair<1>{}, pair<2>{}};
  84         BOOST_HANA_CONSTANT_CHECK(hana::equal(
  85             map,
  86             hana::make_map(pair<0>{}, pair<1>{}, pair<2>{})
  87         ));
  88     }
  89
  90     {
  91         hana::map<pair<0>, pair<1>, pair<2>, pair<3>> map{
  92             pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{}
  93         };
  94         BOOST_HANA_CONSTANT_CHECK(hana::equal(
  95             map,
  96             hana::make_map(pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{})
  97         ));
  98     }
  99
 100     {
 101         hana::map<pair<0>, pair<1>, pair<2>, pair<3>, pair<4>> map{
 102             pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{}, pair<4>{}
 103         };
 104         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 105             map,
 106             hana::make_map(pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{}, pair<4>{})
 107         ));
 108     }
 109
 110     {
 111         hana::map<pair<0>, pair<1>, pair<2>, pair<3>, pair<4>, pair<5>> map{
 112             pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{}, pair<4>{}, pair<5>{}
 113         };
 114         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 115             map,
 116             hana::make_map(pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{}, pair<4>{}, pair<5>{})
 117         ));
 118     }
 119
 120     // Use parenthesis syntax instead of braces
 121     {
 122         hana::map<> map = hana::map<>();
 123         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 124             map,
 125             hana::make_map()
 126         ));
 127     }
 128
 129     {
 130         hana::map<pair<0>> map(
 131             pair<0>{}
 132         );
 133         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 134             map,
 135             hana::make_map(pair<0>{})
 136         ));
 137     }
 138
 139     {
 140         hana::map<pair<0>, pair<1>> map(
 141             pair<0>{}, pair<1>{}
 142         );
 143         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 144             map,
 145             hana::make_map(pair<0>{}, pair<1>{})
 146         ));
 147     }
 148
 149     {
 150         hana::map<pair<0>, pair<1>, pair<2>> map(
 151             pair<0>{}, pair<1>{}, pair<2>{}
 152         );
 153         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 154             map,
 155             hana::make_map(pair<0>{}, pair<1>{}, pair<2>{})
 156         ));
 157     }
 158
 159     {
 160         hana::map<pair<0>, pair<1>, pair<2>, pair<3>> map(
 161             pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{}
 162         );
 163         BOOST_HANA_CONSTANT_CHECK(hana::equal(
 164             map,
 165             hana::make_map(pair<0>{}, pair<1>{}, pair<2>{}, pair<3>{})
 166         ));
 167     }
 168
 169     // Check with move-only types
 170     {
 171         hana::map<hana::pair<TrackedMoveOnly<1>, TrackedMoveOnly<10>>,
 172                   hana::pair<TrackedMoveOnly<2>, TrackedMoveOnly<20>>> map{
 173             hana::make_pair(TrackedMoveOnly<1>{}, TrackedMoveOnly<10>{}),
 174             hana::make_pair(TrackedMoveOnly<2>{}, TrackedMoveOnly<20>{})
 175         };
 176     }
 177
 178     // The following used to fail when we did not constrain the
 179     // constructor properly:
 180     {
 181         hana::map<pair<1>> map{};
 182         hana::test::_injection<0> f{};
 183         auto x = f(map);
 184     }
 185 }