Revision control
Copy as Markdown
// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#ifndef QMAP_H
#define QMAP_H
#include <QtCore/qcompare.h>
#include <QtCore/qhashfunctions.h>
#include <QtCore/qiterator.h>
#include <QtCore/qlist.h>
#include <QtCore/qrefcount.h>
#include <QtCore/qpair.h>
#include <QtCore/qscopeguard.h>
#include <QtCore/qshareddata.h>
#include <QtCore/qshareddata_impl.h>
#include <QtCore/qttypetraits.h>
#include <functional>
#include <initializer_list>
#include <map>
#include <algorithm>
QT_BEGIN_NAMESPACE
// common code shared between QMap and QMultimap
template <typename AMap>
class QMapData : public QSharedData
{
public:
using Map = AMap;
using Key = typename Map::key_type;
using T = typename Map::mapped_type;
using value_type = typename Map::value_type;
using size_type = typename Map::size_type;
using iterator = typename Map::iterator;
using const_iterator = typename Map::const_iterator;
static_assert(std::is_nothrow_destructible_v<Key>, "Types with throwing destructors are not supported in Qt containers.");
static_assert(std::is_nothrow_destructible_v<T>, "Types with throwing destructors are not supported in Qt containers.");
Map m;
QMapData() = default;
explicit QMapData(const Map &other)
: m(other)
{}
explicit QMapData(Map &&other)
: m(std::move(other))
{}
// copies from source all the values not matching key.
// returns how many were NOT copied (removed), and first removed iterator
auto copyIfNotEquivalentTo(const Map &source, const Key &key)
{
Q_ASSERT(m.empty());
size_type result = 0;
auto foundIt = source.end();
const auto markFound = [&](auto it) {
if (result == 0)
foundIt = it;
++result;
};
const auto keep = [this](auto it) { m.insert(m.cend(), *it); };
auto it = source.cbegin();
const auto end = source.cend();
const auto &cmp = m.key_comp();
// Keep all before:
for (; it != end && cmp(it->first, key); ++it)
keep(it);
// Count and skip matches:
for (; it != end && !cmp(key, it->first); ++it)
markFound(it);
// Keep all after:
for (; it != end; ++it)
keep(it);
struct resultType { size_type count; decltype(source.begin()) iterator; };
return resultType{result, foundIt};
}
void copyExceptFor(const Map &source, const iterator &skipit)
{
Q_ASSERT(m.empty());
auto it = source.cend();
const auto end = source.cbegin();
auto hint = m.end();
if (it == end)
return;
do {
--it;
if (it == skipit)
continue;
hint = m.emplace_hint(hint, it->first, it->second);
} while (it != end);
}
// Merges the two sources into this one, giving preference to source2
void fillWithMergeOf(const Map &source1, const Map &source2)
{
Q_ASSERT(m.empty());
auto insertionHint = m.end();
auto src1It = source1.crbegin();
const auto src1End = source1.crend();
auto src2It = source2.crbegin();
const auto src2End = source2.crend();
const auto &keyCompare = m.key_comp();
while (src1It != src1End && src2It != src2End) {
if (keyCompare(src2It->first, src1It->first)) {
insertionHint = m.emplace_hint(insertionHint, src1It->first, src1It->second);
++src1It;
} else if (keyCompare(src1It->first, src2It->first)) {
insertionHint = m.emplace_hint(insertionHint, src2It->first, src2It->second);
++src2It;
} else {
// Equivalence, insert source2, forget source1
insertionHint = m.emplace_hint(insertionHint, src2It->first, src2It->second);
++src1It;
++src2It;
}
}
for (; src1It != src1End; ++src1It)
insertionHint = m.emplace_hint(insertionHint, src1It->first, src1It->second);
for (; src2It != src2End; ++src2It)
insertionHint = m.emplace_hint(insertionHint, src2It->first, src2It->second);
}
// Merge source into this one without changing source as std::map::merge would
void insertMap(const Map &source)
{
Q_ASSERT(!m.empty());
// copy in reverse order, trying to make effective use of insertionHint.
auto insertionHint = m.end();
auto it = source.crbegin();
const auto end = source.crend();
for (; it != end; ++it)
insertionHint = m.emplace_hint(insertionHint, it->first, it->second);
}
// used in key(T), count(Key, T), find(key, T), etc; returns a
// comparator object suitable for algorithms with std::(multi)map
// iterators.
static auto valueIsEqualTo(const T &value)
{
return [&value](const auto &v) { return v.second == value; };
}
Key key(const T &value, const Key &defaultKey) const
{
auto i = std::find_if(m.cbegin(),
m.cend(),
valueIsEqualTo(value));
if (i != m.cend())
return i->first;
return defaultKey;
}
QList<Key> keys() const
{
QList<Key> result;
result.reserve(m.size());
const auto extractKey = [](const auto &v) { return v.first; };
std::transform(m.cbegin(),
m.cend(),
std::back_inserter(result),
extractKey);
return result;
}
QList<Key> keys(const T &value) const
{
QList<Key> result;
result.reserve(m.size());
// no std::transform_if...
for (const auto &v : m) {
if (v.second == value)
result.append(v.first);
}
result.shrink_to_fit();
return result;
}
QList<T> values() const
{
QList<T> result;
result.reserve(m.size());
const auto extractValue = [](const auto &v) { return v.second; };
std::transform(m.cbegin(),
m.cend(),
std::back_inserter(result),
extractValue);
return result;
}
size_type count(const Key &key) const
{
return m.count(key);
}
// Used in erase. Allocates a new QMapData and copies, from this->m,
// the elements not in the [first, last) range. The return contains
// the new QMapData and an iterator in its map pointing at the first
// element after the erase.
struct EraseResult {
QMapData *data;
iterator it;
};
EraseResult erase(const_iterator first, const_iterator last) const
{
EraseResult result;
result.data = new QMapData;
result.it = result.data->m.end();
const auto newDataEnd = result.it;
auto i = m.begin();
const auto e = m.end();
// copy over all the elements before first
while (i != first) {
result.it = result.data->m.insert(newDataEnd, *i);
++i;
}
// skip until last
while (i != last)
++i;
// copy from last to the end
while (i != e) {
result.data->m.insert(newDataEnd, *i);
++i;
}
if (result.it != newDataEnd)
++result.it;
return result;
}
};
// common type traits
namespace QtPrivate {
template <typename Container, typename ...Ts>
using map_has_operator_less_than =
std::conjunction<QTypeTraits::has_operator_less_than_container<Container, Ts>...>;
// The is_base_of<Container, T> check is required for recursive containers.
// Without it MSVC produces errors like:
//
// error C2968:
// 'if_map_has_relational_operators<QMap<NoCmpParamRecursiveMapK, Empty>,
// NoCmpParamRecursiveMapK, Empty>':
// recursive alias declaration
//
// The solution is similar to QTypeTraits::*_container checks.
template <typename Container, typename T>
using map_has_qt_compare_three_way_container =
std::disjunction<std::is_base_of<Container, T>, Qt::has_qt_compare_three_way<T>>;
template <typename Container, typename ...Ts>
using map_has_qt_compare_three_way =
std::conjunction<map_has_qt_compare_three_way_container<Container, Ts>...>;
template <typename Container, typename ...Ts>
using if_map_has_relational_operators =
std::enable_if_t<
std::disjunction_v<
map_has_operator_less_than<Container, Ts...>,
map_has_qt_compare_three_way<Container, Ts...>
>,
bool>;
} // namespace QtPrivate
//
// QMap
//
template <class Key, class T>
class QMap
{
using Map = std::map<Key, T>;
using MapData = QMapData<Map>;
QtPrivate::QExplicitlySharedDataPointerV2<MapData> d;
friend class QMultiMap<Key, T>;
public:
using key_type = Key;
using mapped_type = T;
using difference_type = qptrdiff;
using size_type = qsizetype;
QMap() = default;
// implicitly generated special member functions are OK!
void swap(QMap<Key, T> &other) noexcept
{
d.swap(other.d);
}
QMap(std::initializer_list<std::pair<Key, T>> list)
{
for (auto &p : list)
insert(p.first, p.second);
}
explicit QMap(const std::map<Key, T> &other)
: d(other.empty() ? nullptr : new MapData(other))
{
}
explicit QMap(std::map<Key, T> &&other)
: d(other.empty() ? nullptr : new MapData(std::move(other)))
{
}
std::map<Key, T> toStdMap() const &
{
if (d)
return d->m;
return {};
}
std::map<Key, T> toStdMap() &&
{
if (d) {
if (d.isShared())
return d->m;
else
return std::move(d->m);
}
return {};
}
#ifndef Q_QDOC
private:
template <typename AKey = Key, typename AT = T,
QTypeTraits::compare_eq_result_container<QMap, AKey, AT> = true>
friend bool comparesEqual(const QMap &lhs, const QMap &rhs)
{
if (lhs.d == rhs.d)
return true;
if (!lhs.d)
return rhs == lhs;
Q_ASSERT(lhs.d);
return rhs.d ? (lhs.d->m == rhs.d->m) : lhs.d->m.empty();
}
QT_DECLARE_EQUALITY_OPERATORS_HELPER(QMap, QMap, /* non-constexpr */, noexcept(false),
template <typename AKey = Key, typename AT = T,
QTypeTraits::compare_eq_result_container<QMap, AKey, AT> = true>)
template <typename AKey = Key, typename AT = T,
QtPrivate::if_map_has_relational_operators<QMap, AKey, AT> = true>
friend auto compareThreeWay(const QMap &lhs, const QMap &rhs)
{
return QtOrderingPrivate::lexicographicalCompareThreeWay(lhs.constKeyValueBegin(),
lhs.constKeyValueEnd(),
rhs.constKeyValueBegin(),
rhs.constKeyValueEnd());
}
QT_DECLARE_ORDERING_HELPER_AUTO(QMap, QMap, /* non-constexpr */, noexcept(false),
template <typename AKey = Key, typename AT = T,
QtPrivate::if_map_has_relational_operators<QMap, AKey, AT> = true>)
public:
#else
friend bool operator==(const QMap &lhs, const QMap &rhs);
friend bool operator!=(const QMap &lhs, const QMap &rhs);
friend bool operator<(const QMap &lhs, const QMap &rhs);
friend bool operator>(const QMap &lhs, const QMap &rhs);
friend bool operator<=(const QMap &lhs, const QMap &rhs);
friend bool operator>=(const QMap &lhs, const QMap &rhs);
friend auto operator<=>(const QMap &lhs, const QMap &rhs);
#endif // Q_QDOC
size_type size() const { return d ? size_type(d->m.size()) : size_type(0); }
[[nodiscard]]
bool isEmpty() const { return d ? d->m.empty() : true; }
void detach()
{
if (d)
d.detach();
else
d.reset(new MapData);
}
// A detach for holding an already shared copy, until calling function
// is done using references to keys or values that might reference it.
[[nodiscard]]
QMap referenceHoldingDetach()
{
if (!d) {
d.reset(new MapData);
} else if (d.isShared()) {
auto hold = *this;
d.detach();
return hold;
}
return {};
}
// Specialized version of referenceHoldingDetach(), which will not copy key, if copying
[[nodiscard]]
QMap referenceHoldingDetachExcept(const Key &key)
{
if (!d) {
d.reset(new MapData);
} else if (d.isShared()) {
auto hold = *this;
QtPrivate::QExplicitlySharedDataPointerV2<MapData> newData(new MapData);
newData->copyIfNotEquivalentTo(d->m, key);
d.swap(newData);
return hold;
}
return {};
}
bool isDetached() const noexcept
{
return d ? !d.isShared() : false; // false makes little sense, but that's shared_null's behavior...
}
bool isSharedWith(const QMap<Key, T> &other) const noexcept
{
return d == other.d; // also this makes little sense?
}
void clear()
{
if (!d)
return;
if (!d.isShared())
d->m.clear();
else
d.reset();
}
size_type remove(const Key &key)
{
if (!d)
return 0;
if (!d.isShared())
return size_type(d->m.erase(key));
MapData *newData = new MapData;
size_type result = newData->copyIfNotEquivalentTo(d->m, key).count;
d.reset(newData);
return result;
}
template <typename Predicate>
size_type removeIf(Predicate pred)
{
return QtPrivate::associative_erase_if(*this, pred);
}
T take(const Key &key)
{
if (!d)
return T();
if (d.isShared()) {
MapData *m = new MapData;
// For historic reasons, we always un-share (was: detach()) when
// this function is called, even if `key` isn't found
const auto commit = qScopeGuard([&] { d.reset(m); });
auto result = m->copyIfNotEquivalentTo(d->m, key);
if (result.count)
return result.iterator->second;
// if we reach here, `key` wasn't found:
return T();
}
#ifdef __cpp_lib_node_extract
if (const auto node = d->m.extract(key))
return std::move(node.mapped());
#else
auto i = d->m.find(key);
if (i != d->m.end()) {
// ### breaks RVO on most compilers (but only on old-fashioned ones, so who cares?)
T result(std::move(i->second));
d->m.erase(i);
return result;
}
#endif
return T();
}
bool contains(const Key &key) const
{
if (!d)
return false;
auto i = d->m.find(key);
return i != d->m.end();
}
Key key(const T &value, const Key &defaultKey = Key()) const
{
if (!d)
return defaultKey;
return d->key(value, defaultKey);
}
T value(const Key &key, const T &defaultValue = T()) const
{
if (!d)
return defaultValue;
const auto i = d->m.find(key);
if (i != d->m.cend())
return i->second;
return defaultValue;
}
T &operator[](const Key &key)
{
const auto hold = referenceHoldingDetach();
auto i = d->m.find(key);
if (i == d->m.end())
i = d->m.insert({key, T()}).first;
return i->second;
}
// CHANGE: return T, not const T!
T operator[](const Key &key) const
{
return value(key);
}
QList<Key> keys() const
{
if (!d)
return {};
return d->keys();
}
QList<Key> keys(const T &value) const
{
if (!d)
return {};
return d->keys(value);
}
QList<T> values() const
{
if (!d)
return {};
return d->values();
}
size_type count(const Key &key) const
{
if (!d)
return 0;
return d->count(key);
}
size_type count() const
{
return size();
}
inline const Key &firstKey() const { Q_ASSERT(!isEmpty()); return constBegin().key(); }
inline const Key &lastKey() const { Q_ASSERT(!isEmpty()); return (--constEnd()).key(); }
inline T &first() { Q_ASSERT(!isEmpty()); return *begin(); }
inline const T &first() const { Q_ASSERT(!isEmpty()); return *constBegin(); }
inline T &last() { Q_ASSERT(!isEmpty()); return *(--end()); }
inline const T &last() const { Q_ASSERT(!isEmpty()); return *(--constEnd()); }
class const_iterator;
class iterator
{
friend class QMap<Key, T>;
friend class const_iterator;
typename Map::iterator i;
explicit iterator(typename Map::iterator it) : i(it) {}
public:
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = qptrdiff;
using value_type = T;
using pointer = T *;
using reference = T &;
iterator() = default;
const Key &key() const { return i->first; }
T &value() const { return i->second; }
T &operator*() const { return i->second; }
T *operator->() const { return &i->second; }
friend bool operator==(const iterator &lhs, const iterator &rhs) { return lhs.i == rhs.i; }
friend bool operator!=(const iterator &lhs, const iterator &rhs) { return lhs.i != rhs.i; }
iterator &operator++()
{
++i;
return *this;
}
iterator operator++(int)
{
iterator r = *this;
++i;
return r;
}
iterator &operator--()
{
--i;
return *this;
}
iterator operator--(int)
{
iterator r = *this;
--i;
return r;
}
#if QT_DEPRECATED_SINCE(6, 0)
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMap iterators are not random access")
//! [qmap-op-it-plus-step]
friend iterator operator+(iterator it, difference_type j) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMap iterators are not random access")
//! [qmap-op-it-minus-step]
friend iterator operator-(iterator it, difference_type j) { return std::prev(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::next or std::advance; QMap iterators are not random access")
iterator &operator+=(difference_type j) { std::advance(*this, j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev or std::advance; QMap iterators are not random access")
iterator &operator-=(difference_type j) { std::advance(*this, -j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMap iterators are not random access")
//! [qmap-op-step-plus-it]
friend iterator operator+(difference_type j, iterator it) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMap iterators are not random access")
//! [qmap-op-step-minus-it]
friend iterator operator-(difference_type j, iterator it) { return std::prev(it, j); }
#endif
};
class const_iterator
{
friend class QMap<Key, T>;
typename Map::const_iterator i;
explicit const_iterator(typename Map::const_iterator it) : i(it) {}
public:
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = qptrdiff;
using value_type = T;
using pointer = const T *;
using reference = const T &;
const_iterator() = default;
Q_IMPLICIT const_iterator(const iterator &o) : i(o.i) {}
const Key &key() const { return i->first; }
const T &value() const { return i->second; }
const T &operator*() const { return i->second; }
const T *operator->() const { return &i->second; }
friend bool operator==(const const_iterator &lhs, const const_iterator &rhs) { return lhs.i == rhs.i; }
friend bool operator!=(const const_iterator &lhs, const const_iterator &rhs) { return lhs.i != rhs.i; }
const_iterator &operator++()
{
++i;
return *this;
}
const_iterator operator++(int)
{
const_iterator r = *this;
++i;
return r;
}
const_iterator &operator--()
{
--i;
return *this;
}
const_iterator operator--(int)
{
const_iterator r = *this;
--i;
return r;
}
#if QT_DEPRECATED_SINCE(6, 0)
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMap iterators are not random access")
//! [qmap-op-it-plus-step-const]
friend const_iterator operator+(const_iterator it, difference_type j) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMap iterators are not random access")
//! [qmap-op-it-minus-step-const]
friend const_iterator operator-(const_iterator it, difference_type j) { return std::prev(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::next or std::advance; QMap iterators are not random access")
const_iterator &operator+=(difference_type j) { std::advance(*this, j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev or std::advance; QMap iterators are not random access")
const_iterator &operator-=(difference_type j) { std::advance(*this, -j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMap iterators are not random access")
//! [qmap-op-step-plus-it-const]
friend const_iterator operator+(difference_type j, const_iterator it) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMap iterators are not random access")
//! [qmap-op-step-minus-it-const]
friend const_iterator operator-(difference_type j, const_iterator it) { return std::prev(it, j); }
#endif
};
class key_iterator
{
const_iterator i;
public:
typedef typename const_iterator::iterator_category iterator_category;
typedef typename const_iterator::difference_type difference_type;
typedef Key value_type;
typedef const Key *pointer;
typedef const Key &reference;
key_iterator() = default;
explicit key_iterator(const_iterator o) : i(o) { }
const Key &operator*() const { return i.key(); }
const Key *operator->() const { return &i.key(); }
bool operator==(key_iterator o) const { return i == o.i; }
bool operator!=(key_iterator o) const { return i != o.i; }
inline key_iterator &operator++() { ++i; return *this; }
inline key_iterator operator++(int) { return key_iterator(i++);}
inline key_iterator &operator--() { --i; return *this; }
inline key_iterator operator--(int) { return key_iterator(i--); }
const_iterator base() const { return i; }
};
typedef QKeyValueIterator<const Key&, const T&, const_iterator> const_key_value_iterator;
typedef QKeyValueIterator<const Key&, T&, iterator> key_value_iterator;
// STL style
iterator begin() { detach(); return iterator(d->m.begin()); }
const_iterator begin() const { if (!d) return const_iterator(); return const_iterator(d->m.cbegin()); }
const_iterator constBegin() const { return begin(); }
const_iterator cbegin() const { return begin(); }
iterator end() { detach(); return iterator(d->m.end()); }
const_iterator end() const { if (!d) return const_iterator(); return const_iterator(d->m.end()); }
const_iterator constEnd() const { return end(); }
const_iterator cend() const { return end(); }
key_iterator keyBegin() const { return key_iterator(begin()); }
key_iterator keyEnd() const { return key_iterator(end()); }
key_value_iterator keyValueBegin() { return key_value_iterator(begin()); }
key_value_iterator keyValueEnd() { return key_value_iterator(end()); }
const_key_value_iterator keyValueBegin() const { return const_key_value_iterator(begin()); }
const_key_value_iterator constKeyValueBegin() const { return const_key_value_iterator(begin()); }
const_key_value_iterator keyValueEnd() const { return const_key_value_iterator(end()); }
const_key_value_iterator constKeyValueEnd() const { return const_key_value_iterator(end()); }
auto asKeyValueRange() & { return QtPrivate::QKeyValueRange<QMap &>(*this); }
auto asKeyValueRange() const & { return QtPrivate::QKeyValueRange<const QMap &>(*this); }
auto asKeyValueRange() && { return QtPrivate::QKeyValueRange<QMap>(std::move(*this)); }
auto asKeyValueRange() const && { return QtPrivate::QKeyValueRange<QMap>(std::move(*this)); }
iterator erase(const_iterator it)
{
return erase(it, std::next(it));
}
iterator erase(const_iterator afirst, const_iterator alast)
{
if (!d)
return iterator();
if (!d.isShared())
return iterator(d->m.erase(afirst.i, alast.i));
auto result = d->erase(afirst.i, alast.i);
d.reset(result.data);
return iterator(result.it);
}
// more Qt
typedef iterator Iterator;
typedef const_iterator ConstIterator;
iterator find(const Key &key)
{
const auto hold = referenceHoldingDetach();
return iterator(d->m.find(key));
}
const_iterator find(const Key &key) const
{
if (!d)
return const_iterator();
return const_iterator(d->m.find(key));
}
const_iterator constFind(const Key &key) const
{
return find(key);
}
iterator lowerBound(const Key &key)
{
const auto hold = referenceHoldingDetach();
return iterator(d->m.lower_bound(key));
}
const_iterator lowerBound(const Key &key) const
{
if (!d)
return const_iterator();
return const_iterator(d->m.lower_bound(key));
}
iterator upperBound(const Key &key)
{
const auto hold = referenceHoldingDetach();
return iterator(d->m.upper_bound(key));
}
const_iterator upperBound(const Key &key) const
{
if (!d)
return const_iterator();
return const_iterator(d->m.upper_bound(key));
}
iterator insert(const Key &key, const T &value)
{
const auto hold = referenceHoldingDetachExcept(key);
return iterator(d->m.insert_or_assign(key, value).first);
}
iterator insert(const_iterator pos, const Key &key, const T &value)
{
if (!d) {
detach();
return iterator(d->m.emplace(key, value).first);
} else if (d.isShared()) {
auto posDistance = std::distance(d->m.cbegin(), pos.i);
const auto hold = referenceHoldingDetachExcept(key);
auto dpos = std::next(d->m.cbegin(), posDistance);
return iterator(d->m.insert_or_assign(dpos, key, value));
}
return iterator(d->m.insert_or_assign(pos.i, key, value));
}
void insert(const QMap<Key, T> &map)
{
if (map.isEmpty())
return;
if (isEmpty()) {
*this = map;
return;
}
if (d.isShared()) {
QtPrivate::QExplicitlySharedDataPointerV2<MapData> newD(new MapData);
const auto commit = qScopeGuard([&] { newD.swap(d); });
newD->fillWithMergeOf(d->m, map.d->m);
return;
}
#ifdef __cpp_lib_node_extract
// Since std::map::merge is destructive only use it when not shared
auto copy = map.d->m;
copy.merge(d->m);
d->m = std::move(copy);
#else
QtPrivate::QExplicitlySharedDataPointerV2<MapData> newD(new MapData);
const auto commit = qScopeGuard([&] { newD.swap(d); });
newD->fillWithMergeOf(d->m, map.d->m);
#endif
}
void insert(QMap<Key, T> &&map)
{
if (map.isEmpty() || map.d.isShared()) {
// fall back to a regular copy
insert(map);
return;
}
// Otherwise insert into map, and do a swap on return
const auto commit = qScopeGuard([&] { map.swap(*this); });
if (isEmpty())
return;
if (d.isShared()) {
map.d->insertMap(d->m);
return;
}
#ifdef __cpp_lib_node_extract
map.d->m.merge(std::move(d->m));
#else
// same as above
map.d->insertMap(d->m);
#endif
}
// STL compatibility
[[nodiscard]]
inline bool empty() const
{
return isEmpty();
}
std::pair<iterator, iterator> equal_range(const Key &akey)
{
const auto hold = referenceHoldingDetach();
auto result = d->m.equal_range(akey);
return {iterator(result.first), iterator(result.second)};
}
std::pair<const_iterator, const_iterator> equal_range(const Key &akey) const
{
if (!d)
return {};
auto result = d->m.equal_range(akey);
return {const_iterator(result.first), const_iterator(result.second)};
}
private:
#ifdef Q_QDOC
friend size_t qHash(const QMap &key, size_t seed = 0);
#else
# if defined(Q_CC_GHS) || defined (Q_CC_MSVC)
// GHS and MSVC tries to intantiate qHash() for the noexcept running into a
// non-SFINAE'ed hard error... Create an artificial SFINAE context as a
// work-around:
template <typename M, std::enable_if_t<std::is_same_v<M, QMap>, bool> = true>
friend QtPrivate::QHashMultiReturnType<typename M::key_type, typename M::mapped_type>
# else
using M = QMap;
friend size_t
# endif
qHash(const M &key, size_t seed = 0)
noexcept(QHashPrivate::noexceptPairHash<typename M::key_type, typename M::mapped_type>())
{
if (!key.d)
return seed;
// don't use qHashRange to avoid its compile-time overhead:
return std::accumulate(key.d->m.begin(), key.d->m.end(), seed,
QtPrivate::QHashCombine{seed});
}
#endif // !Q_QDOC
};
Q_DECLARE_ASSOCIATIVE_ITERATOR(Map)
Q_DECLARE_MUTABLE_ASSOCIATIVE_ITERATOR(Map)
template <typename Key, typename T, typename Predicate>
qsizetype erase_if(QMap<Key, T> &map, Predicate pred)
{
return QtPrivate::associative_erase_if(map, pred);
}
//
// QMultiMap
//
template <class Key, class T>
class QMultiMap
{
using Map = std::multimap<Key, T>;
using MapData = QMapData<Map>;
QtPrivate::QExplicitlySharedDataPointerV2<MapData> d;
// Note: methods that look up a single element by key use lower_bound() rather
// than find(). The C++ standard permits std::multimap::find() to return any
// element with the matching key; libc++ 22 changed which one it returns.
// lower_bound() is where insert() places new elements, so it consistently
// identifies the most-recently-inserted one.
auto findIteratorByKey(const Key &key) const
{
auto i = d->m.lower_bound(key);
const auto &cmp = d->m.key_comp();
if (i != d->m.end() && !cmp(key, i->first))
return i;
return d->m.end();
}
auto findIteratorByKey(const Key &key)
{
auto i = d->m.lower_bound(key);
const auto &cmp = d->m.key_comp();
if (i != d->m.end() && !cmp(key, i->first))
return i;
return d->m.end();
}
public:
using key_type = Key;
using mapped_type = T;
using difference_type = qptrdiff;
using size_type = qsizetype;
QMultiMap() = default;
// implicitly generated special member functions are OK!
QMultiMap(std::initializer_list<std::pair<Key,T>> list)
{
for (auto &p : list)
insert(p.first, p.second);
}
void swap(QMultiMap<Key, T> &other) noexcept
{
d.swap(other.d);
}
explicit QMultiMap(const QMap<Key, T> &other)
: d(other.isEmpty() ? nullptr : new MapData)
{
if (d) {
Q_ASSERT(other.d);
d->m.insert(other.d->m.begin(),
other.d->m.end());
}
}
explicit QMultiMap(QMap<Key, T> &&other)
: d(other.isEmpty() ? nullptr : new MapData)
{
if (d) {
Q_ASSERT(other.d);
if (other.d.isShared()) {
d->m.insert(other.d->m.begin(),
other.d->m.end());
} else {
#ifdef __cpp_lib_node_extract
d->m.merge(std::move(other.d->m));
#else
d->m.insert(std::make_move_iterator(other.d->m.begin()),
std::make_move_iterator(other.d->m.end()));
#endif
}
}
}
explicit QMultiMap(const std::multimap<Key, T> &other)
: d(other.empty() ? nullptr : new MapData(other))
{
}
explicit QMultiMap(std::multimap<Key, T> &&other)
: d(other.empty() ? nullptr : new MapData(std::move(other)))
{
}
// CHANGE: return type
Q_DECL_DEPRECATED_X("Use toStdMultiMap instead")
std::multimap<Key, T> toStdMap() const
{
return toStdMultiMap();
}
std::multimap<Key, T> toStdMultiMap() const &
{
if (d)
return d->m;
return {};
}
std::multimap<Key, T> toStdMultiMap() &&
{
if (d) {
if (d.isShared())
return d->m;
else
return std::move(d->m);
}
return {};
}
#ifndef Q_QDOC
private:
template <typename AKey = Key, typename AT = T,
QTypeTraits::compare_eq_result_container<QMultiMap, AKey, AT> = true>
friend bool comparesEqual(const QMultiMap &lhs, const QMultiMap &rhs)
{
if (lhs.d == rhs.d)
return true;
if (!lhs.d)
return rhs == lhs;
Q_ASSERT(lhs.d);
return rhs.d ? (lhs.d->m == rhs.d->m) : lhs.d->m.empty();
}
QT_DECLARE_EQUALITY_OPERATORS_HELPER(QMultiMap, QMultiMap, /* non-constexpr */, noexcept(false),
template <typename AKey = Key, typename AT = T,
QTypeTraits::compare_eq_result_container<QMultiMap, AKey, AT> = true>)
template <typename AKey = Key, typename AT = T,
QtPrivate::if_map_has_relational_operators<QMultiMap, AKey, AT> = true>
friend auto compareThreeWay(const QMultiMap &lhs, const QMultiMap &rhs)
{
return QtOrderingPrivate::lexicographicalCompareThreeWay(lhs.constKeyValueBegin(),
lhs.constKeyValueEnd(),
rhs.constKeyValueBegin(),
rhs.constKeyValueEnd());
}
QT_DECLARE_ORDERING_HELPER_AUTO(QMultiMap, QMultiMap, /* non-constexpr */, noexcept(false),
template <typename AKey = Key, typename AT = T,
QtPrivate::if_map_has_relational_operators<QMultiMap, AKey, AT> = true>)
public:
#else
friend bool operator==(const QMultiMap &lhs, const QMultiMap &rhs);
friend bool operator!=(const QMultiMap &lhs, const QMultiMap &rhs);
friend bool operator<(const QMultiMap &lhs, const QMultiMap &rhs);
friend bool operator>(const QMultiMap &lhs, const QMultiMap &rhs);
friend bool operator<=(const QMultiMap &lhs, const QMultiMap &rhs);
friend bool operator>=(const QMultiMap &lhs, const QMultiMap &rhs);
friend auto operator<=>(const QMultiMap &lhs, const QMultiMap &rhs);
#endif // Q_QDOC
size_type size() const { return d ? size_type(d->m.size()) : size_type(0); }
[[nodiscard]]
bool isEmpty() const { return d ? d->m.empty() : true; }
void detach()
{
if (d)
d.detach();
else
d.reset(new MapData);
}
// A detach for holding an already shared copy, until calling function
// is done using references to keys or values that might reference it.
[[nodiscard]] QMultiMap referenceHoldingDetach()
{
if (!d) {
d.reset(new MapData);
} else if (d.isShared()) {
auto hold = *this;
d.detach();
return hold;
}
return {};
}
// Specialized version of referenceHoldingDetach(), which will not copy skipit, if copying
[[nodiscard]] QMultiMap referenceHoldingDetachExceptFor(const typename Map::iterator &skipit)
{
Q_ASSERT(d.isShared());
auto hold = *this;
QtPrivate::QExplicitlySharedDataPointerV2<MapData> newData(new MapData);
newData->copyExceptFor(d->m, skipit);
d.swap(newData);
return hold;
}
bool isDetached() const noexcept
{
return d ? !d.isShared() : false; // false makes little sense, but that's shared_null's behavior...
}
bool isSharedWith(const QMultiMap<Key, T> &other) const noexcept
{
return d == other.d; // also this makes little sense?
}
void clear()
{
if (!d)
return;
if (!d.isShared())
d->m.clear();
else
d.reset();
}
size_type remove(const Key &key)
{
if (!d)
return 0;
if (!d.isShared())
return size_type(d->m.erase(key));
MapData *newData = new MapData;
size_type result = newData->copyIfNotEquivalentTo(d->m, key).count;
d.reset(newData);
return result;
}
size_type remove(const Key &key, const T &value)
{
if (!d)
return 0;
size_type result = 0;
const auto &keyCompare = d->m.key_comp();
if (d.isShared()) {
QtPrivate::QExplicitlySharedDataPointerV2<MapData> newData(new MapData);
const auto keep = [&newData](auto it) { newData->m.insert(newData->m.cend(), *it); };
auto it = d->m.cbegin();
const auto end = d->m.cend();
for (; it != end && keyCompare(it->first, key); ++it)
keep(it);
// Keep matching keys if value match, otherwise skip and count
for (; it != end && !keyCompare(key, it->first); ++it) {
if (!(it->second == value))
keep(it);
else
++result;
}
for (; it != end; ++it)
keep(it);
d.swap(newData);
return result;
}
// d->m.erase_if(....) would be nice, but that's C++20.
// So let's do like find(keyCopy, valueCopy):
auto [i, e] = d->m.equal_range(key);
if (i == e)
return result;
// value may belong to this map. As such, we need to copy it to ensure
// it stays valid throughout the iteration below (which may destroy it)
const T valueCopy = value;
while (i != e) {
if (i->second == valueCopy) {
i = d->m.erase(i);
++result;
} else {
++i;
}
}
return result;
}
template <typename Predicate>
size_type removeIf(Predicate pred)
{
return QtPrivate::associative_erase_if(*this, pred);
}
T take(const Key &key)
{
if (!d)
return T();
auto i = findIteratorByKey(key);
if (d.isShared()) {
if (i == d->m.end()) {
// NB: take always detaches, even if the key isn't found. This is for historic reasons.
detach();
return T();
}
const auto hold = referenceHoldingDetachExceptFor(i);
return i->second;
}
if (i == d->m.end())
return T();
#ifdef __cpp_lib_node_extract
return std::move(d->m.extract(i).mapped());
#else
// ### breaks RVO on most compilers (but only on old-fashioned ones, so who cares?)
T result(std::move(i->second));
d->m.erase(i);
return result;
#endif
}
bool contains(const Key &key) const
{
if (!d)
return false;
auto i = d->m.find(key);
return i != d->m.end();
}
bool contains(const Key &key, const T &value) const
{
return find(key, value) != end();
}
Key key(const T &value, const Key &defaultKey = Key()) const
{
if (!d)
return defaultKey;
return d->key(value, defaultKey);
}
T value(const Key &key, const T &defaultValue = T()) const
{
if (!d)
return defaultValue;
auto i = findIteratorByKey(key);
if (i != d->m.cend())
return i->second;
return defaultValue;
}
QList<Key> keys() const
{
if (!d)
return {};
return d->keys();
}
QList<Key> keys(const T &value) const
{
if (!d)
return {};
return d->keys(value);
}
QList<Key> uniqueKeys() const
{
QList<Key> result;
if (!d)
return result;
result.reserve(size());
std::unique_copy(keyBegin(), keyEnd(),
std::back_inserter(result));
result.shrink_to_fit();
return result;
}
QList<T> values() const
{
if (!d)
return {};
return d->values();
}
QList<T> values(const Key &key) const
{
QList<T> result;
const auto range = equal_range(key);
result.reserve(std::distance(range.first, range.second));
std::copy(range.first, range.second, std::back_inserter(result));
return result;
}
size_type count(const Key &key) const
{
if (!d)
return 0;
return d->count(key);
}
size_type count(const Key &key, const T &value) const
{
if (!d)
return 0;
// TODO: improve; no need of scanning the equal_range twice.
auto range = d->m.equal_range(key);
return size_type(std::count_if(range.first,
range.second,
MapData::valueIsEqualTo(value)));
}
inline const Key &firstKey() const { Q_ASSERT(!isEmpty()); return constBegin().key(); }
inline const Key &lastKey() const { Q_ASSERT(!isEmpty()); return std::next(constEnd(), -1).key(); }
inline T &first() { Q_ASSERT(!isEmpty()); return *begin(); }
inline const T &first() const { Q_ASSERT(!isEmpty()); return *constBegin(); }
inline T &last() { Q_ASSERT(!isEmpty()); return *std::next(end(), -1); }
inline const T &last() const { Q_ASSERT(!isEmpty()); return *std::next(constEnd(), -1); }
class const_iterator;
class iterator
{
friend class QMultiMap<Key, T>;
friend class const_iterator;
typename Map::iterator i;
explicit iterator(typename Map::iterator it) : i(it) {}
public:
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = qptrdiff;
using value_type = T;
using pointer = T *;
using reference = T &;
iterator() = default;
const Key &key() const { return i->first; }
T &value() const { return i->second; }
T &operator*() const { return i->second; }
T *operator->() const { return &i->second; }
friend bool operator==(const iterator &lhs, const iterator &rhs) { return lhs.i == rhs.i; }
friend bool operator!=(const iterator &lhs, const iterator &rhs) { return lhs.i != rhs.i; }
iterator &operator++()
{
++i;
return *this;
}
iterator operator++(int)
{
iterator r = *this;
++i;
return r;
}
iterator &operator--()
{
--i;
return *this;
}
iterator operator--(int)
{
iterator r = *this;
--i;
return r;
}
#if QT_DEPRECATED_SINCE(6, 0)
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMultiMap iterators are not random access")
//! [qmultimap-op-it-plus-step]
friend iterator operator+(iterator it, difference_type j) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMultiMap iterators are not random access")
//! [qmultimap-op-it-minus-step]
friend iterator operator-(iterator it, difference_type j) { return std::prev(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::next or std::advance; QMultiMap iterators are not random access")
iterator &operator+=(difference_type j) { std::advance(*this, j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev or std::advance; QMultiMap iterators are not random access")
iterator &operator-=(difference_type j) { std::advance(*this, -j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMultiMap iterators are not random access")
//! [qmultimap-op-step-plus-it]
friend iterator operator+(difference_type j, iterator it) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMultiMap iterators are not random access")
//! [qmultimap-op-step-minus-it]
friend iterator operator-(difference_type j, iterator it) { return std::prev(it, j); }
#endif
};
class const_iterator
{
friend class QMultiMap<Key, T>;
typename Map::const_iterator i;
explicit const_iterator(typename Map::const_iterator it) : i(it) {}
public:
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = qptrdiff;
using value_type = T;
using pointer = const T *;
using reference = const T &;
const_iterator() = default;
Q_IMPLICIT const_iterator(const iterator &o) : i(o.i) {}
const Key &key() const { return i->first; }
const T &value() const { return i->second; }
const T &operator*() const { return i->second; }
const T *operator->() const { return &i->second; }
friend bool operator==(const const_iterator &lhs, const const_iterator &rhs) { return lhs.i == rhs.i; }
friend bool operator!=(const const_iterator &lhs, const const_iterator &rhs) { return lhs.i != rhs.i; }
const_iterator &operator++()
{
++i;
return *this;
}
const_iterator operator++(int)
{
const_iterator r = *this;
++i;
return r;
}
const_iterator &operator--()
{
--i;
return *this;
}
const_iterator operator--(int)
{
const_iterator r = *this;
--i;
return r;
}
#if QT_DEPRECATED_SINCE(6, 0)
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMultiMap iterators are not random access")
//! [qmultimap-op-it-plus-step-const]
friend const_iterator operator+(const_iterator it, difference_type j) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMultiMap iterators are not random access")
//! [qmultimap-op-it-minus-step-const]
friend const_iterator operator-(const_iterator it, difference_type j) { return std::prev(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::next or std::advance; QMultiMap iterators are not random access")
const_iterator &operator+=(difference_type j) { std::advance(*this, j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev or std::advance; QMultiMap iterators are not random access")
const_iterator &operator-=(difference_type j) { std::advance(*this, -j); return *this; }
QT_DEPRECATED_VERSION_X_6_0("Use std::next; QMultiMap iterators are not random access")
//! [qmultimap-op-step-plus-it-const]
friend const_iterator operator+(difference_type j, const_iterator it) { return std::next(it, j); }
QT_DEPRECATED_VERSION_X_6_0("Use std::prev; QMultiMap iterators are not random access")
//! [qmultimap-op-step-minus-it-const]
friend const_iterator operator-(difference_type j, const_iterator it) { return std::prev(it, j); }
#endif
};
class key_iterator
{
const_iterator i;
public:
typedef typename const_iterator::iterator_category iterator_category;
typedef typename const_iterator::difference_type difference_type;
typedef Key value_type;
typedef const Key *pointer;
typedef const Key &reference;
key_iterator() = default;
explicit key_iterator(const_iterator o) : i(o) { }
const Key &operator*() const { return i.key(); }
const Key *operator->() const { return &i.key(); }
bool operator==(key_iterator o) const { return i == o.i; }
bool operator!=(key_iterator o) const { return i != o.i; }
inline key_iterator &operator++() { ++i; return *this; }
inline key_iterator operator++(int) { return key_iterator(i++);}
inline key_iterator &operator--() { --i; return *this; }
inline key_iterator operator--(int) { return key_iterator(i--); }
const_iterator base() const { return i; }
};
typedef QKeyValueIterator<const Key&, const T&, const_iterator> const_key_value_iterator;
typedef QKeyValueIterator<const Key&, T&, iterator> key_value_iterator;
// STL style
iterator begin() { detach(); return iterator(d->m.begin()); }
const_iterator begin() const { if (!d) return const_iterator(); return const_iterator(d->m.cbegin()); }
const_iterator constBegin() const { return begin(); }
const_iterator cbegin() const { return begin(); }
iterator end() { detach(); return iterator(d->m.end()); }
const_iterator end() const { if (!d) return const_iterator(); return const_iterator(d->m.end()); }
const_iterator constEnd() const { return end(); }
const_iterator cend() const { return end(); }
key_iterator keyBegin() const { return key_iterator(begin()); }
key_iterator keyEnd() const { return key_iterator(end()); }
key_value_iterator keyValueBegin() { return key_value_iterator(begin()); }
key_value_iterator keyValueEnd() { return key_value_iterator(end()); }
const_key_value_iterator keyValueBegin() const { return const_key_value_iterator(begin()); }
const_key_value_iterator constKeyValueBegin() const { return const_key_value_iterator(begin()); }
const_key_value_iterator keyValueEnd() const { return const_key_value_iterator(end()); }
const_key_value_iterator constKeyValueEnd() const { return const_key_value_iterator(end()); }
auto asKeyValueRange() & { return QtPrivate::QKeyValueRange<QMultiMap &>(*this); }
auto asKeyValueRange() const & { return QtPrivate::QKeyValueRange<const QMultiMap &>(*this); }
auto asKeyValueRange() && { return QtPrivate::QKeyValueRange<QMultiMap>(std::move(*this)); }
auto asKeyValueRange() const && { return QtPrivate::QKeyValueRange<QMultiMap>(std::move(*this)); }
iterator erase(const_iterator it)
{
return erase(it, std::next(it));
}
iterator erase(const_iterator afirst, const_iterator alast)
{
if (!d)
return iterator();
if (!d.isShared())
return iterator(d->m.erase(afirst.i, alast.i));
auto result = d->erase(afirst.i, alast.i);
d.reset(result.data);
return iterator(result.it);
}
// more Qt
typedef iterator Iterator;
typedef const_iterator ConstIterator;
size_type count() const
{
return size();
}
iterator find(const Key &key)
{
const auto hold = referenceHoldingDetach();
return iterator(findIteratorByKey(key));
}
const_iterator find(const Key &key) const
{
if (!d)
return const_iterator();
return const_iterator(findIteratorByKey(key));
}
const_iterator constFind(const Key &key) const
{
return find(key);
}
iterator find(const Key &key, const T &value)
{
const auto hold = referenceHoldingDetach();
auto range = d->m.equal_range(key);
auto i = std::find_if(range.first, range.second,
MapData::valueIsEqualTo(value));
if (i != range.second)
return iterator(i);
return iterator(d->m.end());
}
const_iterator find(const Key &key, const T &value) const
{
if (!d)
return const_iterator();
auto range = d->m.equal_range(key);
auto i = std::find_if(range.first, range.second,
MapData::valueIsEqualTo(value));
if (i != range.second)
return const_iterator(i);
return const_iterator(d->m.end());
}
const_iterator constFind(const Key &key, const T &value) const
{
return find(key, value);
}
iterator lowerBound(const Key &key)
{
const auto hold = referenceHoldingDetach();
return iterator(d->m.lower_bound(key));
}
const_iterator lowerBound(const Key &key) const
{
if (!d)
return const_iterator();
return const_iterator(d->m.lower_bound(key));
}
iterator upperBound(const Key &key)
{
const auto hold = referenceHoldingDetach();
return iterator(d->m.upper_bound(key));
}
const_iterator upperBound(const Key &key) const
{
if (!d)
return const_iterator();
return const_iterator(d->m.upper_bound(key));
}
iterator insert(const Key &key, const T &value)
{
const auto hold = referenceHoldingDetach();
// note that std::multimap inserts at the end of an equal_range for a key,
// QMultiMap at the beginning.
auto i = d->m.lower_bound(key);
return iterator(d->m.insert(i, {key, value}));
}
iterator insert(const_iterator pos, const Key &key, const T &value)
{
if (!d) {
d.reset(new MapData);
return iterator(d->m.insert({ key, value }));
} else if (d.isShared()) {
auto posDistance = std::distance(d->m.cbegin(), pos.i);
auto hold = referenceHoldingDetach();
auto dpos = std::next(d->m.cbegin(), posDistance);
return iterator(d->m.insert(dpos, {key, value}));
}
return iterator(d->m.insert(pos.i, {key, value}));
}
#if QT_DEPRECATED_SINCE(6, 0)
QT_DEPRECATED_VERSION_X_6_0("Use insert() instead")
iterator insertMulti(const Key &key, const T &value)
{
return insert(key, value);
}
QT_DEPRECATED_VERSION_X_6_0("Use insert() instead")
iterator insertMulti(const_iterator pos, const Key &key, const T &value)
{
return insert(pos, key, value);
}
QT_DEPRECATED_VERSION_X_6_0("Use unite() instead")
void insert(const QMultiMap<Key, T> &map)
{
unite(map);
}
QT_DEPRECATED_VERSION_X_6_0("Use unite() instead")
void insert(QMultiMap<Key, T> &&map)
{
unite(std::move(map));
}
#endif
iterator replace(const Key &key, const T &value)
{
if (!d) {
d.reset(new MapData);
return iterator(d->m.insert({ key, value }));
}
auto i = findIteratorByKey(key);
if (d.isShared()) {
const auto hold = referenceHoldingDetachExceptFor(i);
return iterator(d->m.insert({ key, value }));
}
// Similarly, improve here (e.g. lower_bound and hinted insert);
// there's no insert_or_assign on multimaps
if (i != d->m.end())
i->second = value;
else
i = d->m.insert({key, value});
return iterator(i);
}
// STL compatibility
[[nodiscard]]
inline bool empty() const { return isEmpty(); }
std::pair<iterator, iterator> equal_range(const Key &akey)
{
const auto hold = referenceHoldingDetach();
auto result = d->m.equal_range(akey);
return {iterator(result.first), iterator(result.second)};
}
std::pair<const_iterator, const_iterator> equal_range(const Key &akey) const
{
if (!d)
return {};
auto result = d->m.equal_range(akey);
return {const_iterator(result.first), const_iterator(result.second)};
}
QMultiMap &unite(const QMultiMap &other)
{
if (other.isEmpty())
return *this;
detach();
auto copy = other.d->m;
#ifdef __cpp_lib_node_extract
copy.merge(std::move(d->m));
#else
copy.insert(std::make_move_iterator(d->m.begin()),
std::make_move_iterator(d->m.end()));
#endif
d->m = std::move(copy);
return *this;
}
QMultiMap &unite(QMultiMap<Key, T> &&other)
{
if (!other.d || other.d->m.empty())
return *this;
if (other.d.isShared()) {
// fall back to a regular copy
unite(other);
return *this;
}
detach();
#ifdef __cpp_lib_node_extract
other.d->m.merge(std::move(d->m));
#else
other.d->m.insert(std::make_move_iterator(d->m.begin()),
std::make_move_iterator(d->m.end()));
#endif
*this = std::move(other);
return *this;
}
};
Q_DECLARE_ASSOCIATIVE_ITERATOR(MultiMap)
Q_DECLARE_MUTABLE_ASSOCIATIVE_ITERATOR(MultiMap)
template <typename Key, typename T>
QMultiMap<Key, T> operator+(const QMultiMap<Key, T> &lhs, const QMultiMap<Key, T> &rhs)
{
auto result = lhs;
result += rhs;
return result;
}
template <typename Key, typename T>
QMultiMap<Key, T> operator+=(QMultiMap<Key, T> &lhs, const QMultiMap<Key, T> &rhs)
{
return lhs.unite(rhs);
}
template <typename Key, typename T, typename Predicate>
qsizetype erase_if(QMultiMap<Key, T> &map, Predicate pred)
{
return QtPrivate::associative_erase_if(map, pred);
}
QT_END_NAMESPACE
#endif // QMAP_H