359 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++17, c++2010 11// <flat_map>12 13// template<container-compatible-range<value_type> R>14// flat_multimap(from_range_t, R&&)15// template<container-compatible-range<value_type> R>16// flat_multimap(from_range_t, R&&, const key_compare&)17// template<container-compatible-range<value_type> R, class Alloc>18// flat_multimap(from_range_t, R&&, const Alloc&);19// template<container-compatible-range<value_type> R, class Alloc>20// flat_multimap(from_range_t, R&&, const key_compare&, const Alloc&);21 22#include <algorithm>23#include <deque>24#include <flat_map>25#include <functional>26#include <string>27#include <vector>28 29#include "min_allocator.h"30#include "MinSequenceContainer.h"31#include "test_allocator.h"32#include "test_iterators.h"33#include "test_macros.h"34#include "../helpers.h"35#include "../../../test_compare.h"36 37// test constraint container-compatible-range38 39template <class V>40using RangeOf = std::ranges::subrange<V*>;41using Map = std::flat_multimap<int, double>;42 43static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<int, double>>>);44static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<short, double>>>);45static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>>);46static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>>);47 48static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<int, double>>, std::less<int>>);49static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<short, double>>, std::less<int>>);50static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>, std::less<int>>);51static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>, std::less<int>>);52 53static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<int, double>>, std::allocator<int>>);54static_assert(std::is_constructible_v<Map, std::from_range_t, RangeOf<std::pair<short, double>>, std::allocator<int>>);55static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>, std::allocator<int>>);56static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>, std::allocator<int>>);57 58static_assert(std::is_constructible_v<Map,59 std::from_range_t,60 RangeOf<std::pair<int, double>>,61 std::less<int>,62 std::allocator<int>>);63static_assert(std::is_constructible_v<Map,64 std::from_range_t,65 RangeOf<std::pair<short, double>>,66 std::less<int>,67 std::allocator<int>>);68static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<int>, std::less<int>, std::allocator<int>>);69static_assert(!std::is_constructible_v<Map, std::from_range_t, RangeOf<double>, std::less<int>, std::allocator<int>>);70 71template <class KeyContainer, class ValueContainer>72constexpr void test() {73 using Key = typename KeyContainer::value_type;74 using Value = typename ValueContainer::value_type;75 using P = std::pair<Key, Value>;76 P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};77 {78 // flat_multimap(from_range_t, R&&)79 // input_range && !common80 using M = std::flat_multimap<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;81 using Iter = cpp20_input_iterator<const P*>;82 using Sent = sentinel_wrapper<Iter>;83 using R = std::ranges::subrange<Iter, Sent>;84 auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));85 assert(std::ranges::equal(m.keys(), KeyContainer{1, 1, 1, 2, 2, 2, 3, 3, 3}));86 check_possible_values(87 m.values(),88 std::vector<std::vector<Value>>{89 {1, 2, 3},90 {1, 2, 3},91 {1, 2, 3},92 {4, 5, 7},93 {4, 5, 7},94 {4, 5, 7},95 {6, 8, 9},96 {6, 8, 9},97 {6, 8, 9},98 });99 100 // explicit(false)101 M m2 = {std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))};102 assert(m2 == m);103 }104 {105 // flat_multimap(from_range_t, R&&)106 // greater107 using M = std::flat_multimap<Key, Value, std::greater<int>, KeyContainer, ValueContainer>;108 using Iter = cpp20_input_iterator<const P*>;109 using Sent = sentinel_wrapper<Iter>;110 using R = std::ranges::subrange<Iter, Sent>;111 auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));112 assert(std::ranges::equal(m.keys(), KeyContainer{3, 3, 3, 2, 2, 2, 1, 1, 1}));113 check_possible_values(114 m.values(),115 std::vector<std::vector<Value>>{116 {6, 8, 9},117 {6, 8, 9},118 {6, 8, 9},119 {4, 5, 7},120 {4, 5, 7},121 {4, 5, 7},122 {1, 2, 3},123 {1, 2, 3},124 {1, 2, 3},125 });126 }127 {128 // flat_multimap(from_range_t, R&&)129 // contiguous range130 using M = std::flat_multimap<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;131 using R = std::ranges::subrange<const P*>;132 auto m = M(std::from_range, R(ar, ar + 9));133 assert(std::ranges::equal(m.keys(), KeyContainer{1, 1, 1, 2, 2, 2, 3, 3, 3}));134 check_possible_values(135 m.values(),136 std::vector<std::vector<Value>>{137 {1, 2, 3},138 {1, 2, 3},139 {1, 2, 3},140 {4, 5, 7},141 {4, 5, 7},142 {4, 5, 7},143 {6, 8, 9},144 {6, 8, 9},145 {6, 8, 9},146 });147 }148 {149 // flat_multimap(from_range_t, R&&, const key_compare&)150 using C = test_less<int>;151 using M = std::flat_multimap<Key, Value, C, KeyContainer, ValueContainer>;152 using R = std::ranges::subrange<const P*>;153 auto m = M(std::from_range, R(ar, ar + 9), C(3));154 assert(std::ranges::equal(m.keys(), KeyContainer{1, 1, 1, 2, 2, 2, 3, 3, 3}));155 check_possible_values(156 m.values(),157 std::vector<std::vector<Value>>{158 {1, 2, 3},159 {1, 2, 3},160 {1, 2, 3},161 {4, 5, 7},162 {4, 5, 7},163 {4, 5, 7},164 {6, 8, 9},165 {6, 8, 9},166 {6, 8, 9},167 });168 assert(m.key_comp() == C(3));169 170 // explicit(false)171 M m2 = {std::from_range, R(ar, ar + 9), C(3)};172 assert(m2 == m);173 assert(m2.key_comp() == C(3));174 }175}176 177template <template <class...> class KeyContainer, template <class...> class ValueContainer>178constexpr void test_alloc() {179 using P = std::pair<int, short>;180 P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};181 {182 // flat_multimap(from_range_t, R&&, const Allocator&)183 using A1 = test_allocator<int>;184 using A2 = test_allocator<short>;185 using M = std::flat_multimap<int, short, std::less<int>, KeyContainer<int, A1>, ValueContainer<short, A2>>;186 using R = std::ranges::subrange<const P*>;187 auto m = M(std::from_range, R(ar, ar + 9), A1(5));188 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 1, 1, 2, 2, 2, 3, 3, 3}));189 check_possible_values(190 m.values(),191 std::vector<std::vector<short>>{192 {1, 2, 3},193 {1, 2, 3},194 {1, 2, 3},195 {4, 5, 7},196 {4, 5, 7},197 {4, 5, 7},198 {6, 8, 9},199 {6, 8, 9},200 {6, 8, 9},201 });202 assert(m.keys().get_allocator() == A1(5));203 assert(m.values().get_allocator() == A2(5));204 }205 {206 // flat_multimap(from_range_t, R&&, const Allocator&)207 // explicit(false)208 using A1 = test_allocator<int>;209 using A2 = test_allocator<short>;210 using M = std::flat_multimap<int, short, std::less<int>, KeyContainer<int, A1>, ValueContainer<short, A2>>;211 using R = std::ranges::subrange<const P*>;212 M m = {std::from_range, R(ar, ar + 9), A1(5)}; // implicit ctor213 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 1, 1, 2, 2, 2, 3, 3, 3}));214 check_possible_values(215 m.values(),216 std::vector<std::vector<short>>{217 {1, 2, 3},218 {1, 2, 3},219 {1, 2, 3},220 {4, 5, 7},221 {4, 5, 7},222 {4, 5, 7},223 {6, 8, 9},224 {6, 8, 9},225 {6, 8, 9},226 });227 assert(m.keys().get_allocator() == A1(5));228 assert(m.values().get_allocator() == A2(5));229 }230 {231 // flat_multimap(from_range_t, R&&, const key_compare&, const Allocator&)232 using C = test_less<int>;233 using A1 = test_allocator<int>;234 using A2 = test_allocator<short>;235 using M = std::flat_multimap<int, short, C, KeyContainer<int, A1>, ValueContainer<short, A2>>;236 using R = std::ranges::subrange<const P*>;237 auto m = M(std::from_range, R(ar, ar + 9), C(3), A1(5));238 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 1, 1, 2, 2, 2, 3, 3, 3}));239 check_possible_values(240 m.values(),241 std::vector<std::vector<short>>{242 {1, 2, 3},243 {1, 2, 3},244 {1, 2, 3},245 {4, 5, 7},246 {4, 5, 7},247 {4, 5, 7},248 {6, 8, 9},249 {6, 8, 9},250 {6, 8, 9},251 });252 assert(m.key_comp() == C(3));253 assert(m.keys().get_allocator() == A1(5));254 assert(m.values().get_allocator() == A2(5));255 }256 {257 // flat_multimap(from_range_t, R&&, const key_compare&, const Allocator&)258 // explicit(false)259 using A1 = test_allocator<int>;260 using A2 = test_allocator<short>;261 using M = std::flat_multimap<int, short, std::less<int>, KeyContainer<int, A1>, ValueContainer<short, A2>>;262 using R = std::ranges::subrange<const P*>;263 M m = {std::from_range, R(ar, ar + 9), {}, A2(5)}; // implicit ctor264 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 1, 1, 2, 2, 2, 3, 3, 3}));265 check_possible_values(266 m.values(),267 std::vector<std::vector<short>>{268 {1, 2, 3},269 {1, 2, 3},270 {1, 2, 3},271 {4, 5, 7},272 {4, 5, 7},273 {4, 5, 7},274 {6, 8, 9},275 {6, 8, 9},276 {6, 8, 9},277 });278 assert(m.keys().get_allocator() == A1(5));279 assert(m.values().get_allocator() == A2(5));280 }281}282 283constexpr bool test() {284 {285 // The constructors in this subclause shall not participate in overload286 // resolution unless uses_allocator_v<key_container_type, Alloc> is true287 // and uses_allocator_v<mapped_container_type, Alloc> is true.288 289 using C = test_less<int>;290 using A1 = test_allocator<int>;291 using A2 = other_allocator<int>;292 using V1 = std::vector<int, A1>;293 using V2 = std::vector<int, A2>;294 using M1 = std::flat_multimap<int, int, C, V1, V1>;295 using M2 = std::flat_multimap<int, int, C, V1, V2>;296 using M3 = std::flat_multimap<int, int, C, V2, V1>;297 static_assert(std::is_constructible_v<M1, std::from_range_t, M1, const A1&>);298 static_assert(!std::is_constructible_v<M1, std::from_range_t, M1, const A2&>);299 static_assert(!std::is_constructible_v<M2, std::from_range_t, M2, const A2&>);300 static_assert(!std::is_constructible_v<M3, std::from_range_t, M3, const A2&>);301 302 static_assert(std::is_constructible_v<M1, std::from_range_t, M1, const C&, const A1&>);303 static_assert(!std::is_constructible_v<M1, std::from_range_t, M1, const C&, const A2&>);304 static_assert(!std::is_constructible_v<M2, std::from_range_t, M2, const C&, const A2&>);305 static_assert(!std::is_constructible_v<M3, std::from_range_t, M3, const C&, const A2&>);306 }307 {308 // container-compatible-range309 using C = test_less<int>;310 using A1 = test_allocator<int>;311 using A2 = test_allocator<std::string>;312 using M = std::flat_multimap<int, std::string, C, std::vector<int, A1>, std::vector<std::string, A2>>;313 using Pair = std::pair<int, std::string>;314 using PairLike = std::tuple<int, std::string>;315 using NonPairLike = int;316 317 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&>);318 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&>);319 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&>);320 321 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const C&>);322 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const C&>);323 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&>);324 325 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const A1&>);326 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const A1&>);327 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const A1&>);328 329 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const C&, const A1&>);330 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const C&, const A1&>);331 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&, const A1&>);332 }333 334 test<std::vector<int>, std::vector<int>>();335 test<MinSequenceContainer<int>, MinSequenceContainer<double>>();336 test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();337 338 test_alloc<std::vector, std::vector>();339 340#ifndef __cpp_lib_constexpr_deque341 if (!TEST_IS_CONSTANT_EVALUATED)342#endif343 {344 test<std::deque<int>, std::vector<double>>();345 test_alloc<std::deque, std::deque>();346 }347 348 return true;349}350 351int main(int, char**) {352 test();353#if TEST_STD_VER >= 26354 static_assert(test());355#endif356 357 return 0;358}359