1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <map> 11 12 // class multimap 13 14 // template <class... Args> 15 // iterator emplace_hint(const_iterator position, Args&&... args); 16 17 #include <map> 18 #include <cassert> 19 20 #include "../../../Emplaceable.h" 21 #include "DefaultOnly.h" 22 #include "min_allocator.h" 23 main()24 int main() 25 { 26 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 27 { 28 typedef std::multimap<int, DefaultOnly> M; 29 typedef M::iterator R; 30 M m; 31 assert(DefaultOnly::count == 0); 32 R r = m.emplace_hint(m.cend()); 33 assert(r == m.begin()); 34 assert(m.size() == 1); 35 assert(m.begin()->first == 0); 36 assert(m.begin()->second == DefaultOnly()); 37 assert(DefaultOnly::count == 1); 38 r = m.emplace_hint(m.cend(), std::piecewise_construct, 39 std::forward_as_tuple(1), 40 std::forward_as_tuple()); 41 assert(r == next(m.begin())); 42 assert(m.size() == 2); 43 assert(next(m.begin())->first == 1); 44 assert(next(m.begin())->second == DefaultOnly()); 45 assert(DefaultOnly::count == 2); 46 r = m.emplace_hint(m.cend(), std::piecewise_construct, 47 std::forward_as_tuple(1), 48 std::forward_as_tuple()); 49 assert(r == next(m.begin(), 2)); 50 assert(m.size() == 3); 51 assert(next(m.begin(), 2)->first == 1); 52 assert(next(m.begin(), 2)->second == DefaultOnly()); 53 assert(DefaultOnly::count == 3); 54 } 55 assert(DefaultOnly::count == 0); 56 { 57 typedef std::multimap<int, Emplaceable> M; 58 typedef M::iterator R; 59 M m; 60 R r = m.emplace_hint(m.cend(), std::piecewise_construct, 61 std::forward_as_tuple(2), 62 std::forward_as_tuple()); 63 assert(r == m.begin()); 64 assert(m.size() == 1); 65 assert(m.begin()->first == 2); 66 assert(m.begin()->second == Emplaceable()); 67 r = m.emplace_hint(m.cbegin(), std::piecewise_construct, 68 std::forward_as_tuple(1), 69 std::forward_as_tuple(2, 3.5)); 70 assert(r == m.begin()); 71 assert(m.size() == 2); 72 assert(m.begin()->first == 1); 73 assert(m.begin()->second == Emplaceable(2, 3.5)); 74 r = m.emplace_hint(m.cbegin(), std::piecewise_construct, 75 std::forward_as_tuple(1), 76 std::forward_as_tuple(3, 3.5)); 77 assert(r == m.begin()); 78 assert(m.size() == 3); 79 assert(r->first == 1); 80 assert(r->second == Emplaceable(3, 3.5)); 81 } 82 { 83 typedef std::multimap<int, double> M; 84 typedef M::iterator R; 85 M m; 86 R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5)); 87 assert(r == m.begin()); 88 assert(m.size() == 1); 89 assert(m.begin()->first == 2); 90 assert(m.begin()->second == 3.5); 91 } 92 #if __cplusplus >= 201103L 93 { 94 typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M; 95 typedef M::iterator R; 96 M m; 97 assert(DefaultOnly::count == 0); 98 R r = m.emplace_hint(m.cend()); 99 assert(r == m.begin()); 100 assert(m.size() == 1); 101 assert(m.begin()->first == 0); 102 assert(m.begin()->second == DefaultOnly()); 103 assert(DefaultOnly::count == 1); 104 r = m.emplace_hint(m.cend(), std::piecewise_construct, 105 std::forward_as_tuple(1), 106 std::forward_as_tuple()); 107 assert(r == next(m.begin())); 108 assert(m.size() == 2); 109 assert(next(m.begin())->first == 1); 110 assert(next(m.begin())->second == DefaultOnly()); 111 assert(DefaultOnly::count == 2); 112 r = m.emplace_hint(m.cend(), std::piecewise_construct, 113 std::forward_as_tuple(1), 114 std::forward_as_tuple()); 115 assert(r == next(m.begin(), 2)); 116 assert(m.size() == 3); 117 assert(next(m.begin(), 2)->first == 1); 118 assert(next(m.begin(), 2)->second == DefaultOnly()); 119 assert(DefaultOnly::count == 3); 120 } 121 assert(DefaultOnly::count == 0); 122 { 123 typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M; 124 typedef M::iterator R; 125 M m; 126 R r = m.emplace_hint(m.cend(), std::piecewise_construct, 127 std::forward_as_tuple(2), 128 std::forward_as_tuple()); 129 assert(r == m.begin()); 130 assert(m.size() == 1); 131 assert(m.begin()->first == 2); 132 assert(m.begin()->second == Emplaceable()); 133 r = m.emplace_hint(m.cbegin(), std::piecewise_construct, 134 std::forward_as_tuple(1), 135 std::forward_as_tuple(2, 3.5)); 136 assert(r == m.begin()); 137 assert(m.size() == 2); 138 assert(m.begin()->first == 1); 139 assert(m.begin()->second == Emplaceable(2, 3.5)); 140 r = m.emplace_hint(m.cbegin(), std::piecewise_construct, 141 std::forward_as_tuple(1), 142 std::forward_as_tuple(3, 3.5)); 143 assert(r == m.begin()); 144 assert(m.size() == 3); 145 assert(r->first == 1); 146 assert(r->second == Emplaceable(3, 3.5)); 147 } 148 { 149 typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; 150 typedef M::iterator R; 151 M m; 152 R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5)); 153 assert(r == m.begin()); 154 assert(m.size() == 1); 155 assert(m.begin()->first == 2); 156 assert(m.begin()->second == 3.5); 157 } 158 #endif 159 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 160 } 161