ceph/src/boost/libs/spirit/test/x3/container_support.cpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2015 Joel de Guzman
   3     Copyright (c) 2001-2011 Hartmut Kaiser
   4
   5     Distributed under the Boost Software License, Version 1.0. (See accompanying
   6     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 =============================================================================*/
   8 #include <boost/spirit/home/x3.hpp>
   9 #include <boost/fusion/include/std_pair.hpp>
  10
  11 #include <iostream>
  12 #include <map>
  13 #include <unordered_map>
  14 #include <boost/unordered_map.hpp>
  15 #include <vector>
  16 #include <list>
  17 #include <deque>
  18 #include <set>
  19 #include <unordered_set>
  20 #include <boost/unordered_set.hpp>
  21 #include <string>
  22 #include "test.hpp"
  23
  24 namespace x3 = boost::spirit::x3;
  25
  26
  27 // check if we did not break user defined specializations
  28 namespace check_substitute {
  29 template <typename T> struct foo {};
  30 template <typename T> struct bar { using type = T; };
  31 template <typename T> struct is_bar : std::false_type {};
  32 template <typename T> struct is_bar<bar<T>> : std::true_type {};
  33 }
  34
  35 namespace boost { namespace spirit { namespace x3 { namespace traits {
  36 using namespace check_substitute;
  37
  38 template <typename T, typename U>
  39 struct is_substitute<foo<T>, foo<U>> : is_substitute<T, U> {};
  40
  41 template <typename T, typename U>
  42 struct is_substitute<T, U, std::enable_if_t<is_bar<T>::value && is_bar<U>::value>>
  43   : is_substitute<typename T::type, typename U::type> {};
  44 }}}}
  45
  46 namespace check_substitute {
  47 using x3::traits::is_substitute;
  48 static_assert(is_substitute<foo<int>, foo<int>>::value, "is_substitute problem");
  49 static_assert(!is_substitute<foo<int>, foo<long>>::value, "is_substitute problem");
  50 static_assert(is_substitute<bar<int>, bar<int>>::value, "is_substitute problem");
  51 static_assert(!is_substitute<bar<int>, bar<long>>::value, "is_substitute problem");
  52 }
  53
  54
  55 x3::rule<class pair_rule, std::pair<std::string,std::string>> const pair_rule("pair");
  56 x3::rule<class string_rule, std::string> const string_rule("string");
  57
  58 auto const pair_rule_def = string_rule > x3::lit('=') > string_rule;
  59 auto const string_rule_def = x3::lexeme[*x3::alnum];
  60
  61 BOOST_SPIRIT_DEFINE(pair_rule, string_rule)
  62
  63 template <typename Container>
  64 void test_map_support()
  65 {
  66     using spirit_test::test_attr;
  67
  68     Container container;
  69     Container const compare {{"k1", "v1"}, {"k2", "v2"}};
  70     auto const rule = pair_rule % x3::lit(',');
  71
  72     BOOST_TEST(test_attr("k1=v1,k2=v2,k2=v3", rule, container));
  73     BOOST_TEST(container.size() == 2);
  74     BOOST_TEST(container == compare);
  75
  76     // test sequences parsing into containers
  77     auto const seq_rule = pair_rule >> ',' >> pair_rule >> ',' >> pair_rule;
  78     container.clear();
  79     BOOST_TEST(test_attr("k1=v1,k2=v2,k2=v3", seq_rule, container));
  80
  81     // test parsing container into container
  82     auto const cic_rule = pair_rule >> +(',' >> pair_rule);
  83     container.clear();
  84     BOOST_TEST(test_attr("k1=v1,k2=v2,k2=v3", cic_rule, container));
  85 }
  86
  87 template <typename Container>
  88 void test_multimap_support()
  89 {
  90     using spirit_test::test_attr;
  91
  92     Container container;
  93     Container const compare {{"k1", "v1"}, {"k2", "v2"}, {"k2", "v3"}};
  94     auto const rule = pair_rule % x3::lit(',');
  95
  96     BOOST_TEST(test_attr("k1=v1,k2=v2,k2=v3", rule, container));
  97     BOOST_TEST(container.size() == 3);
  98     BOOST_TEST(container == compare);
  99
 100     // test sequences parsing into containers
 101     auto const seq_rule = pair_rule >> ',' >> pair_rule >> ',' >> pair_rule;
 102     container.clear();
 103     BOOST_TEST(test_attr("k1=v1,k2=v2,k2=v3", seq_rule, container));
 104
 105     // test parsing container into container
 106     auto const cic_rule = pair_rule >> +(',' >> pair_rule);
 107     container.clear();
 108     BOOST_TEST(test_attr("k1=v1,k2=v2,k2=v3", cic_rule, container));
 109 }
 110
 111 template <typename Container>
 112 void test_sequence_support()
 113 {
 114     using spirit_test::test_attr;
 115
 116     Container container;
 117     Container const compare {"e1", "e2", "e2"};
 118     auto const rule = string_rule % x3::lit(',');
 119
 120     BOOST_TEST(test_attr("e1,e2,e2", rule, container));
 121     BOOST_TEST(container.size() == 3);
 122     BOOST_TEST(container == compare);
 123
 124     // test sequences parsing into containers
 125     auto const seq_rule = string_rule >> ',' >> string_rule >> ',' >> string_rule;
 126     container.clear();
 127     BOOST_TEST(test_attr("e1,e2,e2", seq_rule, container));
 128
 129     // test parsing container into container
 130     auto const cic_rule = string_rule >> +(',' >> string_rule);
 131     container.clear();
 132     BOOST_TEST(test_attr("e1,e2,e2", cic_rule, container));
 133 }
 134
 135 template <typename Container>
 136 void test_set_support()
 137 {
 138     using spirit_test::test_attr;
 139
 140     Container container;
 141     Container const compare {"e1", "e2"};
 142     auto const rule = string_rule % x3::lit(',');
 143
 144     BOOST_TEST(test_attr("e1,e2,e2", rule, container));
 145     BOOST_TEST(container.size() == 2);
 146     BOOST_TEST(container == compare);
 147
 148     // test sequences parsing into containers
 149     auto const seq_rule = string_rule >> ',' >> string_rule >> ',' >> string_rule;
 150     container.clear();
 151     BOOST_TEST(test_attr("e1,e2,e2", seq_rule, container));
 152
 153     // test parsing container into container
 154     auto const cic_rule = string_rule >> +(',' >> string_rule);
 155     container.clear();
 156     BOOST_TEST(test_attr("e1,e2,e2", cic_rule, container));
 157 }
 158
 159 template <typename Container>
 160 void test_multiset_support()
 161 {
 162     using spirit_test::test_attr;
 163
 164     Container container;
 165     Container const compare {"e1", "e2", "e2"};
 166     auto const rule = string_rule % x3::lit(',');
 167
 168     BOOST_TEST(test_attr("e1,e2,e2", rule, container));
 169     BOOST_TEST(container.size() == 3);
 170     BOOST_TEST(container == compare);
 171
 172     // test sequences parsing into containers
 173     auto const seq_rule = string_rule >> ',' >> string_rule >> ',' >> string_rule;
 174     container.clear();
 175     BOOST_TEST(test_attr("e1,e2,e2", seq_rule, container));
 176
 177     // test parsing container into container
 178     auto const cic_rule = string_rule >> +(',' >> string_rule);
 179     container.clear();
 180     BOOST_TEST(test_attr("e1,e2,e2", cic_rule, container));
 181 }
 182
 183 template <typename Container>
 184 void test_string_support()
 185 {
 186     using spirit_test::test_attr;
 187
 188     Container container;
 189     Container const compare {"e1e2e2"};
 190     auto const rule = string_rule % x3::lit(',');
 191
 192     BOOST_TEST(test_attr("e1,e2,e2", rule, container));
 193     BOOST_TEST(container.size() == 6);
 194     BOOST_TEST(container == compare);
 195
 196     // test sequences parsing into containers
 197     auto const seq_rule = string_rule >> ',' >> string_rule >> ',' >> string_rule;
 198     container.clear();
 199     BOOST_TEST(test_attr("e1,e2,e2", seq_rule, container));
 200
 201     // test parsing container into container
 202     auto const cic_rule = string_rule >> +(',' >> string_rule);
 203     container.clear();
 204     BOOST_TEST(test_attr("e1,e2,e2", cic_rule, container));
 205 }
 206
 207 int
 208 main()
 209 {
 210     using x3::traits::is_associative;
 211
 212     // ------------------------------------------------------------------
 213
 214     static_assert(is_associative<std::set<int>>::value, "is_associative problem");
 215     static_assert(is_associative<std::unordered_set<int>>::value, "is_associative problem");
 216     static_assert(is_associative<boost::unordered_set<int>>::value, "is_associative problem");
 217     static_assert(is_associative<std::multiset<int>>::value, "is_associative problem");
 218     static_assert(is_associative<std::unordered_multiset<int>>::value, "is_associative problem");
 219     static_assert(is_associative<boost::unordered_multiset<int>>::value, "is_associative problem");
 220     static_assert(is_associative<std::map<int,int>>::value, "is_associative problem");
 221     static_assert(is_associative<std::unordered_map<int,int>>::value, "is_associative problem");
 222     static_assert(is_associative<boost::unordered_map<int,int>>::value, "is_associative problem");
 223     static_assert(is_associative<std::multimap<int,int>>::value, "is_associative problem");
 224     static_assert(is_associative<std::unordered_multimap<int,int>>::value, "is_associative problem");
 225     static_assert(is_associative<boost::unordered_multimap<int,int>>::value, "is_associative problem");
 226
 227     static_assert(!is_associative<std::vector<int>>::value, "is_associative problem");
 228     static_assert(!is_associative<std::string>::value, "is_associative problem");
 229     static_assert(!is_associative<std::deque<int>>::value, "is_associative problem");
 230     static_assert(!is_associative<std::list<int>>::value, "is_associative problem");
 231
 232     // ------------------------------------------------------------------
 233
 234     test_string_support<std::string>();
 235
 236     test_sequence_support<std::vector<std::string>>();
 237     test_sequence_support<std::list<std::string>>();
 238     test_sequence_support<std::deque<std::string>>();
 239
 240     test_set_support<std::set<std::string>>();
 241     test_set_support<std::unordered_set<std::string>>();
 242     test_set_support<boost::unordered_set<std::string>>();
 243
 244     test_multiset_support<std::multiset<std::string>>();
 245     test_multiset_support<std::unordered_multiset<std::string>>();
 246     test_multiset_support<boost::unordered_multiset<std::string>>();
 247
 248     test_map_support<std::map<std::string,std::string>>();
 249     test_map_support<std::unordered_map<std::string,std::string>>();
 250     test_map_support<boost::unordered_map<std::string,std::string>>();
 251
 252     test_multimap_support<std::multimap<std::string,std::string>>();
 253     test_multimap_support<std::unordered_multimap<std::string,std::string>>();
 254     test_multimap_support<boost::unordered_multimap<std::string,std::string>>();
 255
 256     return boost::report_errors();
 257 }