Skip to content

Commit

Permalink
Support pair-like arguments in map::insert and map::emplace
Browse files Browse the repository at this point in the history
  • Loading branch information
@morzhovets
morzhovets committed Nov 25, 2024
1 parent fcc610f commit e8fc6dd
Show file tree
Hide file tree
Showing 7 changed files with 92 additions and 224 deletions.
118 changes: 22 additions & 96 deletions include/momo/stdish/map.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -485,68 +485,18 @@ namespace internal
return { lower_bound(key), upper_bound(key) };
}

//template<typename Value>
//momo::internal::EnableIf<std::is_constructible<value_type, Value>::value,
//std::pair<iterator, bool>> insert(Value&& value)

//template<typename Value>
//momo::internal::EnableIf<std::is_constructible<value_type, Value>::value,
//iterator> insert(const_iterator hint, Value&& value)

//std::pair<iterator, bool> insert(value_type&& value)

//iterator insert(const_iterator hint, value_type&& value)

//std::pair<iterator, bool> insert(const value_type& value)

//iterator insert(const_iterator hint, const value_type& value)

std::pair<iterator, bool> insert(std::pair<key_type, mapped_type>&& value)
{
return ptEmplace(nullptr, std::forward_as_tuple(std::move(value.first)),
std::forward_as_tuple(std::move(value.second)));
}

iterator insert(const_iterator hint, std::pair<key_type, mapped_type>&& value)
{
return ptEmplace(hint, std::forward_as_tuple(std::move(value.first)),
std::forward_as_tuple(std::move(value.second))).first;
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
std::pair<iterator, bool>> insert(const std::pair<First, Second>& value)
{
return ptEmplace(nullptr, std::forward_as_tuple(value.first),
std::forward_as_tuple(value.second));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
iterator> insert(const_iterator hint, const std::pair<First, Second>& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
std::pair<iterator, bool>> insert(ValueArg&& valueArg)
{
return ptEmplace(hint, std::forward_as_tuple(value.first),
std::forward_as_tuple(value.second)).first;
return emplace(std::forward<ValueArg>(valueArg));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
std::pair<iterator, bool>> insert(std::pair<First, Second>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
iterator> insert(const_iterator hint, ValueArg&& valueArg)
{
return ptEmplace(nullptr, std::forward_as_tuple(std::forward<First>(value.first)),
std::forward_as_tuple(std::forward<Second>(value.second)));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
iterator> insert(const_iterator hint, std::pair<First, Second>&& value)
{
return ptEmplace(hint, std::forward_as_tuple(std::forward<First>(value.first)),
std::forward_as_tuple(std::forward<Second>(value.second))).first;
return emplace_hint(hint, std::forward<ValueArg>(valueArg));
}

insert_return_type insert(node_type&& node)
Expand Down Expand Up @@ -603,13 +553,17 @@ namespace internal
template<typename ValueArg>
std::pair<iterator, bool> emplace(ValueArg&& valueArg)
{
return insert(std::forward<ValueArg>(valueArg));
return ptEmplace(nullptr,
std::forward_as_tuple(std::get<0>(std::forward<ValueArg>(valueArg))),
std::forward_as_tuple(std::get<1>(std::forward<ValueArg>(valueArg))));
}

template<typename ValueArg>
iterator emplace_hint(const_iterator hint, ValueArg&& valueArg)
{
return insert(hint, std::forward<ValueArg>(valueArg));
return ptEmplace(hint,
std::forward_as_tuple(std::get<0>(std::forward<ValueArg>(valueArg))),
std::forward_as_tuple(std::get<1>(std::forward<ValueArg>(valueArg)))).first;
}

template<typename KeyArg, typename MappedArg>
Expand Down Expand Up @@ -1053,46 +1007,18 @@ class multimap : public internal::map_base<TKey, TMapped, TLessFunc, TAllocator,

//using BaseMap::insert; // gcc 5 & 6

iterator insert(std::pair<key_type, mapped_type>&& value)
{
return BaseMap::insert(std::move(value)).first;
}

iterator insert(const_iterator hint, std::pair<key_type, mapped_type>&& value)
{
return BaseMap::insert(hint, std::move(value));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
iterator> insert(const std::pair<First, Second>& value)
{
return BaseMap::insert(value).first;
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
iterator> insert(const_iterator hint, const std::pair<First, Second>& value)
{
return BaseMap::insert(hint, value);
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
iterator> insert(std::pair<First, Second>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
iterator> insert(ValueArg&& valueArg)
{
return BaseMap::insert(std::move(value)).first;
return BaseMap::insert(std::forward<ValueArg>(valueArg)).first;
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
iterator> insert(const_iterator hint, std::pair<First, Second>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
iterator> insert(const_iterator hint, ValueArg&& valueArg)
{
return BaseMap::insert(hint, std::move(value));
return BaseMap::insert(hint, std::forward<ValueArg>(valueArg));
}

iterator insert(node_type&& node)
Expand Down
74 changes: 14 additions & 60 deletions include/momo/stdish/unordered_map.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -504,68 +504,18 @@ class unordered_map
return { find(key), end() };
}

//template<typename Value>
//momo::internal::EnableIf<std::is_constructible<value_type, Value>::value,
//std::pair<iterator, bool>> insert(Value&& value)

//template<typename Value>
//momo::internal::EnableIf<std::is_constructible<value_type, Value>::value,
//iterator> insert(const_iterator hint, Value&& value)

//std::pair<iterator, bool> insert(value_type&& value)

//iterator insert(const_iterator hint, value_type&& value)

//std::pair<iterator, bool> insert(const value_type& value)

//iterator insert(const_iterator hint, const value_type& value)

std::pair<iterator, bool> insert(std::pair<key_type, mapped_type>&& value)
{
return pvEmplace(nullptr, std::forward_as_tuple(std::move(value.first)),
std::forward_as_tuple(std::move(value.second)));
}

iterator insert(const_iterator hint, std::pair<key_type, mapped_type>&& value)
{
return pvEmplace(hint, std::forward_as_tuple(std::move(value.first)),
std::forward_as_tuple(std::move(value.second))).first;
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
std::pair<iterator, bool>> insert(const std::pair<First, Second>& value)
{
return pvEmplace(nullptr, std::forward_as_tuple(value.first),
std::forward_as_tuple(value.second));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
iterator> insert(const_iterator hint, const std::pair<First, Second>& value)
{
return pvEmplace(hint, std::forward_as_tuple(value.first),
std::forward_as_tuple(value.second)).first;
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
std::pair<iterator, bool>> insert(std::pair<First, Second>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
std::pair<iterator, bool>> insert(ValueArg&& valueArg)
{
return pvEmplace(nullptr, std::forward_as_tuple(std::forward<First>(value.first)),
std::forward_as_tuple(std::forward<Second>(value.second)));
return emplace(std::forward<ValueArg>(valueArg));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
iterator> insert(const_iterator hint, std::pair<First, Second>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
iterator> insert(const_iterator hint, ValueArg&& valueArg)
{
return pvEmplace(hint, std::forward_as_tuple(std::forward<First>(value.first)),
std::forward_as_tuple(std::forward<Second>(value.second))).first;
return emplace_hint(hint, std::forward<ValueArg>(valueArg));
}

insert_return_type insert(node_type&& node)
Expand Down Expand Up @@ -624,13 +574,17 @@ class unordered_map
template<typename ValueArg>
std::pair<iterator, bool> emplace(ValueArg&& valueArg)
{
return insert(std::forward<ValueArg>(valueArg));
return pvEmplace(nullptr,
std::forward_as_tuple(std::get<0>(std::forward<ValueArg>(valueArg))),
std::forward_as_tuple(std::get<1>(std::forward<ValueArg>(valueArg))));
}

template<typename ValueArg>
iterator emplace_hint(const_iterator hint, ValueArg&& valueArg)
{
return insert(hint, std::forward<ValueArg>(valueArg));
return pvEmplace(hint,
std::forward_as_tuple(std::get<0>(std::forward<ValueArg>(valueArg))),
std::forward_as_tuple(std::get<1>(std::forward<ValueArg>(valueArg)))).first;
}

template<typename KeyArg, typename MappedArg>
Expand Down
65 changes: 10 additions & 55 deletions include/momo/stdish/unordered_multimap.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -467,64 +467,18 @@ class unordered_multimap
return pvEqualRange<iterator, IteratorProxy>(mHashMultiMap, mHashMultiMap.Find(key));
}

//template<typename Value>
//momo::internal::EnableIf<std::is_constructible<value_type, Value>::value,
//iterator> insert(Value&& value)

//template<typename Value>
//momo::internal::EnableIf<std::is_constructible<value_type, Value>::value,
//iterator> insert(const_iterator hint, Value&& value)

//iterator insert(value_type&& value)

//iterator insert(const_iterator hint, value_type&& value)

//iterator insert(const value_type& value)

//iterator insert(const_iterator hint, const value_type& value)

iterator insert(std::pair<key_type, mapped_type>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
iterator> insert(ValueArg&& valueArg)
{
return pvEmplace(std::forward_as_tuple(std::move(value.first)),
std::forward_as_tuple(std::move(value.second)));
}

iterator insert(const_iterator, std::pair<key_type, mapped_type>&& value)
{
return insert(std::move(value));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
iterator> insert(const std::pair<First, Second>& value)
{
return pvEmplace(std::forward_as_tuple(value.first), std::forward_as_tuple(value.second));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, const First&>::value
&& std::is_constructible<mapped_type, const Second&>::value,
iterator> insert(const_iterator, const std::pair<First, Second>& value)
{
return insert(value);
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
iterator> insert(std::pair<First, Second>&& value)
{
return pvEmplace(std::forward_as_tuple(std::forward<First>(value.first)),
std::forward_as_tuple(std::forward<Second>(value.second)));
return emplace(std::forward<ValueArg>(valueArg));
}

template<typename First, typename Second>
momo::internal::EnableIf<std::is_constructible<key_type, First&&>::value
&& std::is_constructible<mapped_type, Second&&>::value,
iterator> insert(const_iterator, std::pair<First, Second>&& value)
template<typename ValueArg = std::pair<key_type, mapped_type>>
momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
iterator> insert(const_iterator, ValueArg&& valueArg)
{
return insert(std::move(value));
return insert(std::forward<ValueArg>(valueArg));
}

template<typename Iterator>
Expand Down Expand Up @@ -560,7 +514,8 @@ class unordered_multimap
template<typename ValueArg>
iterator emplace(ValueArg&& valueArg)
{
return insert(std::forward<ValueArg>(valueArg));
return pvEmplace(std::forward_as_tuple(std::get<0>(std::forward<ValueArg>(valueArg))),
std::forward_as_tuple(std::get<1>(std::forward<ValueArg>(valueArg))));
}

template<typename ValueArg>
Expand Down
13 changes: 13 additions & 0 deletions test/sources/libcxx/map/extra/emplace_ext.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,13 @@ void main()
assert(m.size() == 3);
assert(m.begin()->first == 0);
assert(m.begin()->second == 0.0);

r = m.emplace(std::make_tuple(-1, 4.5));
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 4);
assert(m.begin()->first == -1);
assert(m.begin()->second == 4.5);
}
{
typedef std::map<std::string, double> M;
Expand Down Expand Up @@ -89,5 +96,11 @@ void main()
assert(m.size() == 3);
assert(m.begin()->first == 0);
assert(m.begin()->second == 0.0);

r = m.emplace_hint(m.end(), std::make_tuple(-1, 4.5));
assert(r == m.begin());
assert(m.size() == 4);
assert(m.begin()->first == -1);
assert(m.begin()->second == 4.5);
}
}
Loading

0 comments on commit e8fc6dd

Please sign in to comment.