311 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_map(from_range_t, R&&)15// template<container-compatible-range<value_type> R>16// flat_map(from_range_t, R&&, const key_compare&)17// template<container-compatible-range<value_type> R, class Alloc>18// flat_map(from_range_t, R&&, const Alloc&);19// template<container-compatible-range<value_type> R, class Alloc>20// flat_map(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_map<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_map(from_range_t, R&&)79 // input_range && !common80 using M = std::flat_map<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, 2, 3}));86 check_possible_values(87 m.values(),88 std::vector<std::vector<Value>>{89 {1, 2, 3},90 {4, 5, 7},91 {6, 8, 9},92 });93 94 // explicit(false)95 M m2 = {std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))};96 assert(m2 == m);97 }98 {99 // flat_map(from_range_t, R&&)100 // greater101 using M = std::flat_map<Key, Value, std::greater<int>, KeyContainer, ValueContainer>;102 using Iter = cpp20_input_iterator<const P*>;103 using Sent = sentinel_wrapper<Iter>;104 using R = std::ranges::subrange<Iter, Sent>;105 auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9))));106 assert(std::ranges::equal(m.keys(), KeyContainer{3, 2, 1}));107 check_possible_values(108 m.values(),109 std::vector<std::vector<Value>>{110 {6, 8, 9},111 {4, 5, 7},112 {1, 2, 3},113 });114 }115 {116 // flat_map(from_range_t, R&&)117 // contiguous range118 using M = std::flat_map<Key, Value, std::less<Key>, KeyContainer, ValueContainer>;119 using R = std::ranges::subrange<const P*>;120 auto m = M(std::from_range, R(ar, ar + 9));121 assert(std::ranges::equal(m.keys(), KeyContainer{1, 2, 3}));122 check_possible_values(123 m.values(),124 std::vector<std::vector<Value>>{125 {1, 2, 3},126 {4, 5, 7},127 {6, 8, 9},128 });129 }130 {131 // flat_map(from_range_t, R&&, const key_compare&)132 using C = test_less<int>;133 using M = std::flat_map<Key, Value, C, KeyContainer, ValueContainer>;134 using R = std::ranges::subrange<const P*>;135 auto m = M(std::from_range, R(ar, ar + 9), C(3));136 assert(std::ranges::equal(m.keys(), KeyContainer{1, 2, 3}));137 check_possible_values(138 m.values(),139 std::vector<std::vector<Value>>{140 {1, 2, 3},141 {4, 5, 7},142 {6, 8, 9},143 });144 assert(m.key_comp() == C(3));145 146 // explicit(false)147 M m2 = {std::from_range, R(ar, ar + 9), C(3)};148 assert(m2 == m);149 assert(m2.key_comp() == C(3));150 }151}152 153template <template <class...> class KeyContainer, template <class...> class ValueContainer>154constexpr void test_alloc() {155 using P = std::pair<int, short>;156 P ar[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};157 {158 // flat_map(from_range_t, R&&, const Allocator&)159 using A1 = test_allocator<int>;160 using A2 = test_allocator<short>;161 using M = std::flat_map<int, short, std::less<int>, KeyContainer<int, A1>, ValueContainer<short, A2>>;162 using R = std::ranges::subrange<const P*>;163 auto m = M(std::from_range, R(ar, ar + 9), A1(5));164 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 2, 3}));165 check_possible_values(166 m.values(),167 std::vector<std::vector<short>>{168 {1, 2, 3},169 {4, 5, 7},170 {6, 8, 9},171 });172 assert(m.keys().get_allocator() == A1(5));173 assert(m.values().get_allocator() == A2(5));174 }175 {176 // flat_map(from_range_t, R&&, const Allocator&)177 // explicit(false)178 using A1 = test_allocator<int>;179 using A2 = test_allocator<short>;180 using M = std::flat_map<int, short, std::less<int>, KeyContainer<int, A1>, ValueContainer<short, A2>>;181 using R = std::ranges::subrange<const P*>;182 M m = {std::from_range, R(ar, ar + 9), A1(5)}; // implicit ctor183 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 2, 3}));184 check_possible_values(185 m.values(),186 std::vector<std::vector<short>>{187 {1, 2, 3},188 {4, 5, 7},189 {6, 8, 9},190 });191 assert(m.keys().get_allocator() == A1(5));192 assert(m.values().get_allocator() == A2(5));193 }194 {195 // flat_map(from_range_t, R&&, const key_compare&, const Allocator&)196 using C = test_less<int>;197 using A1 = test_allocator<int>;198 using A2 = test_allocator<short>;199 using M = std::flat_map<int, short, C, KeyContainer<int, A1>, ValueContainer<short, A2>>;200 using R = std::ranges::subrange<const P*>;201 auto m = M(std::from_range, R(ar, ar + 9), C(3), A1(5));202 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 2, 3}));203 check_possible_values(204 m.values(),205 std::vector<std::vector<short>>{206 {1, 2, 3},207 {4, 5, 7},208 {6, 8, 9},209 });210 assert(m.key_comp() == C(3));211 assert(m.keys().get_allocator() == A1(5));212 assert(m.values().get_allocator() == A2(5));213 }214 {215 // flat_map(from_range_t, R&&, const key_compare&, const Allocator&)216 // explicit(false)217 using A1 = test_allocator<int>;218 using A2 = test_allocator<short>;219 using M = std::flat_map<int, short, std::less<int>, KeyContainer<int, A1>, ValueContainer<short, A2>>;220 using R = std::ranges::subrange<const P*>;221 M m = {std::from_range, R(ar, ar + 9), {}, A2(5)}; // implicit ctor222 assert(std::ranges::equal(m.keys(), KeyContainer<int, A1>{1, 2, 3}));223 check_possible_values(224 m.values(),225 std::vector<std::vector<short>>{226 {1, 2, 3},227 {4, 5, 7},228 {6, 8, 9},229 });230 assert(m.keys().get_allocator() == A1(5));231 assert(m.values().get_allocator() == A2(5));232 }233}234 235constexpr bool test() {236 {237 // The constructors in this subclause shall not participate in overload238 // resolution unless uses_allocator_v<key_container_type, Alloc> is true239 // and uses_allocator_v<mapped_container_type, Alloc> is true.240 241 using C = test_less<int>;242 using A1 = test_allocator<int>;243 using A2 = other_allocator<int>;244 using V1 = std::vector<int, A1>;245 using V2 = std::vector<int, A2>;246 using M1 = std::flat_map<int, int, C, V1, V1>;247 using M2 = std::flat_map<int, int, C, V1, V2>;248 using M3 = std::flat_map<int, int, C, V2, V1>;249 static_assert(std::is_constructible_v<M1, std::from_range_t, M1, const A1&>);250 static_assert(!std::is_constructible_v<M1, std::from_range_t, M1, const A2&>);251 static_assert(!std::is_constructible_v<M2, std::from_range_t, M2, const A2&>);252 static_assert(!std::is_constructible_v<M3, std::from_range_t, M3, const A2&>);253 254 static_assert(std::is_constructible_v<M1, std::from_range_t, M1, const C&, const A1&>);255 static_assert(!std::is_constructible_v<M1, std::from_range_t, M1, const C&, const A2&>);256 static_assert(!std::is_constructible_v<M2, std::from_range_t, M2, const C&, const A2&>);257 static_assert(!std::is_constructible_v<M3, std::from_range_t, M3, const C&, const A2&>);258 }259 {260 // container-compatible-range261 using C = test_less<int>;262 using A1 = test_allocator<int>;263 using A2 = test_allocator<std::string>;264 using M = std::flat_map<int, std::string, C, std::vector<int, A1>, std::vector<std::string, A2>>;265 using Pair = std::pair<int, std::string>;266 using PairLike = std::tuple<int, std::string>;267 using NonPairLike = int;268 269 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&>);270 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&>);271 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&>);272 273 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const C&>);274 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const C&>);275 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&>);276 277 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const A1&>);278 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const A1&>);279 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const A1&>);280 281 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<Pair>&, const C&, const A1&>);282 static_assert(std::is_constructible_v<M, std::from_range_t, std::vector<PairLike>&, const C&, const A1&>);283 static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&, const A1&>);284 }285 286 test<std::vector<int>, std::vector<int>>();287 test<MinSequenceContainer<int>, MinSequenceContainer<double>>();288 test<std::vector<int, min_allocator<int>>, std::vector<double, min_allocator<double>>>();289 290 test_alloc<std::vector, std::vector>();291 292#ifndef __cpp_lib_constexpr_deque293 if (!TEST_IS_CONSTANT_EVALUATED)294#endif295 {296 test<std::deque<int>, std::vector<double>>();297 test_alloc<std::deque, std::deque>();298 }299 300 return true;301}302 303int main(int, char**) {304 test();305#if TEST_STD_VER >= 26306 static_assert(test());307#endif308 309 return 0;310}311