2014-06-04 13:11:25 +02:00
|
|
|
/****************************************************************************
|
|
|
|
|
**
|
2016-01-15 14:58:39 +01:00
|
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
|
|
|
** Contact: https://www.qt.io/licensing/
|
2014-06-04 13:11:25 +02:00
|
|
|
**
|
|
|
|
|
** This file is part of Qt Creator.
|
|
|
|
|
**
|
|
|
|
|
** Commercial License Usage
|
|
|
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
|
|
|
** accordance with the commercial license agreement provided with the
|
|
|
|
|
** Software or, alternatively, in accordance with the terms contained in
|
2016-01-15 14:58:39 +01:00
|
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
|
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
|
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
2014-06-04 13:11:25 +02:00
|
|
|
**
|
2016-01-15 14:58:39 +01:00
|
|
|
** GNU General Public License Usage
|
|
|
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
|
|
|
** General Public License version 3 as published by the Free Software
|
|
|
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
|
|
|
** included in the packaging of this file. Please review the following
|
|
|
|
|
** information to ensure the GNU General Public License requirements will
|
|
|
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
2014-06-04 13:11:25 +02:00
|
|
|
**
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
2016-03-18 07:55:01 +01:00
|
|
|
#pragma once
|
2014-06-04 13:11:25 +02:00
|
|
|
|
2017-10-25 14:32:45 +02:00
|
|
|
#include "predicates.h"
|
2018-01-09 15:32:47 +01:00
|
|
|
#include "optional.h"
|
2017-10-25 14:32:45 +02:00
|
|
|
|
2014-08-29 13:18:41 +02:00
|
|
|
#include <qcompilerdetection.h> // for Q_REQUIRED_RESULT
|
|
|
|
|
|
2014-06-04 13:11:25 +02:00
|
|
|
#include <algorithm>
|
2017-12-17 15:41:56 +01:00
|
|
|
#include <map>
|
2017-11-28 17:58:24 +01:00
|
|
|
#include <memory>
|
2017-12-15 13:52:47 +01:00
|
|
|
#include <set>
|
2015-10-27 11:01:34 +01:00
|
|
|
#include <tuple>
|
2017-12-17 15:41:56 +01:00
|
|
|
#include <unordered_map>
|
|
|
|
|
#include <unordered_set>
|
2015-10-27 11:01:34 +01:00
|
|
|
|
2017-11-14 09:26:38 +01:00
|
|
|
#include <QObject>
|
2019-01-29 08:41:57 +01:00
|
|
|
#include <QSet>
|
2014-10-30 15:42:42 +01:00
|
|
|
#include <QStringList>
|
2014-06-04 13:11:25 +02:00
|
|
|
|
2017-12-01 11:22:58 +01:00
|
|
|
#include <memory>
|
2018-08-30 14:13:23 +02:00
|
|
|
#include <type_traits>
|
2017-12-01 11:22:58 +01:00
|
|
|
|
2014-06-04 13:11:25 +02:00
|
|
|
namespace Utils
|
|
|
|
|
{
|
2018-01-18 11:10:03 +01:00
|
|
|
|
2019-05-13 14:26:11 +02:00
|
|
|
/////////////////////////
|
|
|
|
|
// anyOf
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename T, typename F>
|
|
|
|
|
bool anyOf(const T &container, F predicate);
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
bool anyOf(const T &container, R (S::*predicate)() const);
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
bool anyOf(const T &container, R S::*member);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// count
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename T, typename F>
|
|
|
|
|
int count(const T &container, F predicate);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// allOf
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename T, typename F>
|
|
|
|
|
bool allOf(const T &container, F predicate);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// erase
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename T, typename F>
|
|
|
|
|
void erase(T &container, F predicate);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// contains
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename T, typename F>
|
|
|
|
|
bool contains(const T &container, F function);
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
bool contains(const T &container, R (S::*function)() const);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
bool contains(const C &container, R S::*member);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// findOr
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT typename C::value_type findOr(const C &container,
|
|
|
|
|
typename C::value_type other,
|
|
|
|
|
F function);
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT typename T::value_type findOr(const T &container,
|
|
|
|
|
typename T::value_type other,
|
|
|
|
|
R (S::*function)() const);
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT typename T::value_type findOr(const T &container,
|
|
|
|
|
typename T::value_type other,
|
|
|
|
|
R S::*member);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// findOrDefault
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT typename std::enable_if_t<std::is_copy_assignable<typename C::value_type>::value,
|
|
|
|
|
typename C::value_type>
|
|
|
|
|
findOrDefault(const C &container, F function);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT typename std::enable_if_t<std::is_copy_assignable<typename C::value_type>::value,
|
|
|
|
|
typename C::value_type>
|
|
|
|
|
findOrDefault(const C &container, R (S::*function)() const);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT typename std::enable_if_t<std::is_copy_assignable<typename C::value_type>::value,
|
|
|
|
|
typename C::value_type>
|
|
|
|
|
findOrDefault(const C &container, R S::*member);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// indexOf
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT int indexOf(const C &container, F function);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// maxElementOr
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename T>
|
|
|
|
|
typename T::value_type maxElementOr(const T &container, typename T::value_type other);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// filtered
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT C filtered(const C &container, F predicate);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT C filtered(const C &container, R (S::*predicate)() const);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// partition
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// Recommended usage:
|
|
|
|
|
// C hit;
|
|
|
|
|
// C miss;
|
|
|
|
|
// std::tie(hit, miss) = Utils::partition(container, predicate);
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT std::tuple<C, C> partition(const C &container, F predicate);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT std::tuple<C, C> partition(const C &container, R (S::*predicate)() const);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// filteredUnique
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename C>
|
|
|
|
|
Q_REQUIRED_RESULT C filteredUnique(const C &container);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// qobject_container_cast
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<class T, template<typename> class Container, typename Base>
|
|
|
|
|
Container<T> qobject_container_cast(const Container<Base> &container);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// static_container_cast
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<class T, template<typename> class Container, typename Base>
|
|
|
|
|
Container<T> static_container_cast(const Container<Base> &container);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// sort
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename Container>
|
|
|
|
|
inline void sort(Container &container);
|
|
|
|
|
template<typename Container, typename Predicate>
|
|
|
|
|
inline void sort(Container &container, Predicate p);
|
|
|
|
|
template<typename Container, typename R, typename S>
|
|
|
|
|
inline void sort(Container &container, R S::*member);
|
|
|
|
|
template<typename Container, typename R, typename S>
|
|
|
|
|
inline void sort(Container &container, R (S::*function)() const);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// reverseForeach
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename Container, typename Op>
|
|
|
|
|
inline void reverseForeach(const Container &c, const Op &operation);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// toReferences
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<template<typename...> class ResultContainer, typename SourceContainer>
|
|
|
|
|
auto toReferences(SourceContainer &sources);
|
|
|
|
|
template<typename SourceContainer>
|
|
|
|
|
auto toReferences(SourceContainer &sources);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// toConstReferences
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<template<typename...> class ResultContainer, typename SourceContainer>
|
|
|
|
|
auto toConstReferences(const SourceContainer &sources);
|
|
|
|
|
template<typename SourceContainer>
|
|
|
|
|
auto toConstReferences(const SourceContainer &sources);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// take
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<class C, typename P>
|
|
|
|
|
Q_REQUIRED_RESULT optional<typename C::value_type> take(C &container, P predicate);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) take(C &container, R S::*member);
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) take(C &container, R (S::*function)() const);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// setUnionMerge
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// Works like std::set_union but provides a merge function for items that match
|
|
|
|
|
// !(a > b) && !(b > a) which normally means that there is an "equal" match.
|
|
|
|
|
// It uses iterators to support move_iterators.
|
|
|
|
|
template<class InputIt1, class InputIt2, class OutputIt, class Merge, class Compare>
|
|
|
|
|
OutputIt setUnionMerge(InputIt1 first1,
|
|
|
|
|
InputIt1 last1,
|
|
|
|
|
InputIt2 first2,
|
|
|
|
|
InputIt2 last2,
|
|
|
|
|
OutputIt d_first,
|
|
|
|
|
Merge merge,
|
|
|
|
|
Compare comp);
|
|
|
|
|
template<class InputIt1, class InputIt2, class OutputIt, class Merge>
|
|
|
|
|
OutputIt setUnionMerge(
|
|
|
|
|
InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first, Merge merge);
|
|
|
|
|
template<class OutputContainer, class InputContainer1, class InputContainer2, class Merge, class Compare>
|
|
|
|
|
OutputContainer setUnionMerge(InputContainer1 &&input1,
|
|
|
|
|
InputContainer2 &&input2,
|
|
|
|
|
Merge merge,
|
|
|
|
|
Compare comp);
|
|
|
|
|
template<class OutputContainer, class InputContainer1, class InputContainer2, class Merge>
|
|
|
|
|
OutputContainer setUnionMerge(InputContainer1 &&input1, InputContainer2 &&input2, Merge merge);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// usize / ssize
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename Container>
|
|
|
|
|
std::make_unsigned_t<typename Container::size_type> usize(Container container);
|
|
|
|
|
template<typename Container>
|
|
|
|
|
std::make_signed_t<typename Container::size_type> ssize(Container container);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// setUnion
|
|
|
|
|
/////////////////////////
|
|
|
|
|
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
|
|
|
|
|
OutputIterator set_union(InputIterator1 first1,
|
|
|
|
|
InputIterator1 last1,
|
|
|
|
|
InputIterator2 first2,
|
|
|
|
|
InputIterator2 last2,
|
|
|
|
|
OutputIterator result,
|
|
|
|
|
Compare comp);
|
|
|
|
|
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
|
|
|
|
|
OutputIterator set_union(InputIterator1 first1,
|
|
|
|
|
InputIterator1 last1,
|
|
|
|
|
InputIterator2 first2,
|
|
|
|
|
InputIterator2 last2,
|
|
|
|
|
OutputIterator result);
|
|
|
|
|
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// transform
|
|
|
|
|
/////////////////////////
|
|
|
|
|
// function without result type deduction:
|
|
|
|
|
template<typename ResultContainer, // complete result container type
|
|
|
|
|
typename SC, // input container type
|
|
|
|
|
typename F> // function type
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, F function);
|
|
|
|
|
|
|
|
|
|
// function with result type deduction:
|
|
|
|
|
template<template<typename> class C, // result container type
|
|
|
|
|
typename SC, // input container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename Value = typename std::decay_t<SC>::value_type,
|
|
|
|
|
typename Result = std::decay_t<std::result_of_t<F(Value &)>>,
|
|
|
|
|
typename ResultContainer = C<Result>>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, F function);
|
|
|
|
|
template<template<typename, typename> class C, // result container type
|
|
|
|
|
typename SC, // input container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename Value = typename std::decay_t<SC>::value_type,
|
|
|
|
|
typename Result = std::decay_t<std::result_of_t<F(Value &)>>,
|
|
|
|
|
typename ResultContainer = C<Result, std::allocator<Result>>>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, F function);
|
|
|
|
|
|
|
|
|
|
// member function without result type deduction:
|
|
|
|
|
template<template<typename...> class C, // result container type
|
|
|
|
|
typename SC, // input container type
|
|
|
|
|
typename R,
|
|
|
|
|
typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, R (S::*p)() const);
|
|
|
|
|
|
|
|
|
|
// member function with result type deduction:
|
|
|
|
|
template<typename ResultContainer, // complete result container type
|
|
|
|
|
typename SC, // input container type
|
|
|
|
|
typename R,
|
|
|
|
|
typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, R (S::*p)() const);
|
|
|
|
|
|
|
|
|
|
// member without result type deduction:
|
|
|
|
|
template<typename ResultContainer, // complete result container type
|
|
|
|
|
typename SC, // input container
|
|
|
|
|
typename R,
|
|
|
|
|
typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, R S::*p);
|
|
|
|
|
|
|
|
|
|
// member with result type deduction:
|
|
|
|
|
template<template<typename...> class C, // result container
|
|
|
|
|
typename SC, // input container
|
|
|
|
|
typename R,
|
|
|
|
|
typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, R S::*p);
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, const input
|
|
|
|
|
// function:
|
|
|
|
|
template<template<typename...> class C, // container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(const C<CArgs...> &container, F function);
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, const input
|
|
|
|
|
// member function:
|
|
|
|
|
template<template<typename...> class C, // container type
|
|
|
|
|
typename R,
|
|
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(const C<CArgs...> &container, R (S::*p)() const);
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, const input
|
|
|
|
|
// members:
|
|
|
|
|
template<template<typename...> class C, // container
|
|
|
|
|
typename R,
|
|
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(const C<CArgs...> &container, R S::*p);
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, non-const input
|
|
|
|
|
// function:
|
|
|
|
|
template<template<typename...> class C, // container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(C<CArgs...> &container, F function);
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, non-const input
|
|
|
|
|
// member function:
|
|
|
|
|
template<template<typename...> class C, // container type
|
|
|
|
|
typename R,
|
|
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(C<CArgs...> &container, R (S::*p)() const);
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, non-const input
|
|
|
|
|
// members:
|
|
|
|
|
template<template<typename...> class C, // container
|
|
|
|
|
typename R,
|
|
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(C<CArgs...> &container, R S::*p);
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
//////// Implementations //////////////////////////////////////////////
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// anyOf
|
|
|
|
|
/////////////////
|
2017-12-01 11:01:19 +01:00
|
|
|
template<typename T, typename F>
|
|
|
|
|
bool anyOf(const T &container, F predicate)
|
|
|
|
|
{
|
|
|
|
|
return std::any_of(std::begin(container), std::end(container), predicate);
|
|
|
|
|
}
|
2014-07-07 19:02:26 +02:00
|
|
|
|
|
|
|
|
// anyOf taking a member function pointer
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
bool anyOf(const T &container, R (S::*predicate)() const)
|
|
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
return std::any_of(std::begin(container), std::end(container), std::mem_fn(predicate));
|
2014-07-07 19:02:26 +02:00
|
|
|
}
|
2014-06-04 13:11:25 +02:00
|
|
|
|
2017-12-01 11:01:19 +01:00
|
|
|
// anyOf taking a member pointer
|
|
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
bool anyOf(const T &container, R S::*member)
|
2014-06-12 16:24:52 +02:00
|
|
|
{
|
2017-12-01 11:01:19 +01:00
|
|
|
return std::any_of(std::begin(container), std::end(container), std::mem_fn(member));
|
2014-06-12 16:24:52 +02:00
|
|
|
}
|
|
|
|
|
|
2017-12-01 11:01:19 +01:00
|
|
|
|
|
|
|
|
//////////////////
|
|
|
|
|
// count
|
|
|
|
|
/////////////////
|
2014-08-06 16:54:18 +02:00
|
|
|
template<typename T, typename F>
|
|
|
|
|
int count(const T &container, F predicate)
|
|
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
return std::count_if(std::begin(container), std::end(container), predicate);
|
2014-08-06 16:54:18 +02:00
|
|
|
}
|
|
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// allOf
|
|
|
|
|
/////////////////
|
2014-06-12 16:24:52 +02:00
|
|
|
template<typename T, typename F>
|
|
|
|
|
bool allOf(const T &container, F predicate)
|
|
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
return std::all_of(std::begin(container), std::end(container), predicate);
|
2014-06-12 16:24:52 +02:00
|
|
|
}
|
|
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// erase
|
|
|
|
|
/////////////////
|
2014-06-12 16:24:52 +02:00
|
|
|
template<typename T, typename F>
|
2017-11-27 11:31:15 +01:00
|
|
|
void erase(T &container, F predicate)
|
2014-06-12 16:24:52 +02:00
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
container.erase(std::remove_if(std::begin(container), std::end(container), predicate),
|
|
|
|
|
std::end(container));
|
2014-06-12 16:24:52 +02:00
|
|
|
}
|
|
|
|
|
|
2017-11-27 11:31:15 +01:00
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// contains
|
|
|
|
|
/////////////////
|
2014-06-06 13:12:47 +02:00
|
|
|
template<typename T, typename F>
|
|
|
|
|
bool contains(const T &container, F function)
|
|
|
|
|
{
|
2017-11-30 17:03:22 +01:00
|
|
|
return anyOf(container, function);
|
|
|
|
|
}
|
2014-06-06 13:12:47 +02:00
|
|
|
|
2017-11-30 17:03:22 +01:00
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
bool contains(const T &container, R (S::*function)() const)
|
|
|
|
|
{
|
|
|
|
|
return anyOf(container, function);
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-18 11:10:03 +01:00
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
bool contains(const C &container, R S::*member)
|
2017-11-30 17:03:22 +01:00
|
|
|
{
|
2018-01-18 11:10:03 +01:00
|
|
|
return anyOf(container, std::mem_fn(member));
|
2014-06-06 13:12:47 +02:00
|
|
|
}
|
|
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// findOr
|
|
|
|
|
/////////////////
|
2017-12-01 11:22:58 +01:00
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
typename C::value_type findOr(const C &container, typename C::value_type other, F function)
|
|
|
|
|
{
|
|
|
|
|
typename C::const_iterator begin = std::begin(container);
|
|
|
|
|
typename C::const_iterator end = std::end(container);
|
|
|
|
|
|
|
|
|
|
typename C::const_iterator it = std::find_if(begin, end, function);
|
|
|
|
|
return it == end ? other : *it;
|
2017-11-28 16:30:49 +01:00
|
|
|
}
|
|
|
|
|
|
2015-09-04 14:26:34 +02:00
|
|
|
template<typename T, typename R, typename S>
|
2017-12-01 11:22:58 +01:00
|
|
|
Q_REQUIRED_RESULT
|
2015-09-04 14:26:34 +02:00
|
|
|
typename T::value_type findOr(const T &container, typename T::value_type other, R (S::*function)() const)
|
|
|
|
|
{
|
|
|
|
|
return findOr(container, other, std::mem_fn(function));
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-01 11:22:58 +01:00
|
|
|
template<typename T, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
typename T::value_type findOr(const T &container, typename T::value_type other, R S::*member)
|
2017-11-28 16:30:49 +01:00
|
|
|
{
|
2017-12-01 11:22:58 +01:00
|
|
|
return findOr(container, other, std::mem_fn(member));
|
2017-11-28 16:30:49 +01:00
|
|
|
}
|
2015-09-04 14:26:34 +02:00
|
|
|
|
2017-12-01 11:22:58 +01:00
|
|
|
//////////////////
|
|
|
|
|
// findOrDefault
|
|
|
|
|
//////////////////
|
|
|
|
|
// Default implementation:
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT
|
2018-01-18 11:10:03 +01:00
|
|
|
typename std::enable_if_t<std::is_copy_assignable<typename C::value_type>::value, typename C::value_type>
|
|
|
|
|
findOrDefault(const C &container, F function)
|
2015-09-04 14:26:34 +02:00
|
|
|
{
|
2017-12-01 11:22:58 +01:00
|
|
|
return findOr(container, typename C::value_type(), function);
|
2015-09-04 14:26:34 +02:00
|
|
|
}
|
|
|
|
|
|
2017-12-01 11:22:58 +01:00
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT
|
2018-01-18 11:10:03 +01:00
|
|
|
typename std::enable_if_t<std::is_copy_assignable<typename C::value_type>::value, typename C::value_type>
|
|
|
|
|
findOrDefault(const C &container, R (S::*function)() const)
|
2017-11-28 16:30:49 +01:00
|
|
|
{
|
2017-12-01 11:22:58 +01:00
|
|
|
return findOr(container, typename C::value_type(), std::mem_fn(function));
|
2017-11-28 16:30:49 +01:00
|
|
|
}
|
|
|
|
|
|
2017-12-01 11:22:58 +01:00
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT
|
2018-01-18 11:10:03 +01:00
|
|
|
typename std::enable_if_t<std::is_copy_assignable<typename C::value_type>::value, typename C::value_type>
|
|
|
|
|
findOrDefault(const C &container, R S::*member)
|
2017-11-28 16:30:49 +01:00
|
|
|
{
|
2017-12-01 11:22:58 +01:00
|
|
|
return findOr(container, typename C::value_type(), std::mem_fn(member));
|
2017-11-28 16:30:49 +01:00
|
|
|
}
|
|
|
|
|
|
2017-12-01 11:30:41 +01:00
|
|
|
//////////////////
|
|
|
|
|
// index of:
|
|
|
|
|
//////////////////
|
|
|
|
|
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
int indexOf(const C& container, F function)
|
|
|
|
|
{
|
|
|
|
|
typename C::const_iterator begin = std::begin(container);
|
|
|
|
|
typename C::const_iterator end = std::end(container);
|
|
|
|
|
|
|
|
|
|
typename C::const_iterator it = std::find_if(begin, end, function);
|
|
|
|
|
return it == end ? -1 : std::distance(begin, it);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-05-05 20:34:29 +02:00
|
|
|
//////////////////
|
|
|
|
|
// max element
|
|
|
|
|
//////////////////
|
|
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
|
typename T::value_type maxElementOr(const T &container, typename T::value_type other)
|
|
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
typename T::const_iterator begin = std::begin(container);
|
|
|
|
|
typename T::const_iterator end = std::end(container);
|
2017-05-05 20:34:29 +02:00
|
|
|
|
|
|
|
|
typename T::const_iterator it = std::max_element(begin, end);
|
|
|
|
|
if (it == end)
|
|
|
|
|
return other;
|
|
|
|
|
return *it;
|
|
|
|
|
}
|
2015-04-21 12:42:17 -07:00
|
|
|
|
2017-12-01 11:22:58 +01:00
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// transform
|
|
|
|
|
/////////////////
|
|
|
|
|
|
2014-10-30 15:42:42 +01:00
|
|
|
namespace {
|
|
|
|
|
/////////////////
|
|
|
|
|
// helper code for transform to use back_inserter and thus push_back for everything
|
|
|
|
|
// and insert for QSet<>
|
|
|
|
|
//
|
|
|
|
|
|
2017-12-15 13:52:47 +01:00
|
|
|
// SetInsertIterator, straight from the standard for insert_iterator
|
2014-10-30 15:42:42 +01:00
|
|
|
// just without the additional parameter to insert
|
|
|
|
|
template <class Container>
|
2017-12-15 13:52:47 +01:00
|
|
|
class SetInsertIterator :
|
2014-10-30 15:42:42 +01:00
|
|
|
public std::iterator<std::output_iterator_tag,void,void,void,void>
|
|
|
|
|
{
|
|
|
|
|
protected:
|
|
|
|
|
Container *container;
|
|
|
|
|
|
|
|
|
|
public:
|
2018-07-23 10:45:40 +02:00
|
|
|
using container_type = Container;
|
2017-12-15 13:52:47 +01:00
|
|
|
explicit SetInsertIterator (Container &x)
|
2014-10-30 15:42:42 +01:00
|
|
|
: container(&x) {}
|
2017-12-15 13:52:47 +01:00
|
|
|
SetInsertIterator<Container> &operator=(const typename Container::value_type &value)
|
2014-10-30 15:42:42 +01:00
|
|
|
{ container->insert(value); return *this; }
|
2017-12-15 13:52:47 +01:00
|
|
|
SetInsertIterator<Container> &operator= (typename Container::value_type &&value)
|
2014-10-30 15:42:42 +01:00
|
|
|
{ container->insert(std::move(value)); return *this; }
|
2017-12-15 13:52:47 +01:00
|
|
|
SetInsertIterator<Container >&operator*()
|
2014-10-30 15:42:42 +01:00
|
|
|
{ return *this; }
|
2017-12-15 13:52:47 +01:00
|
|
|
SetInsertIterator<Container> &operator++()
|
2014-10-30 15:42:42 +01:00
|
|
|
{ return *this; }
|
2017-12-15 13:52:47 +01:00
|
|
|
SetInsertIterator<Container> operator++(int)
|
2014-10-30 15:42:42 +01:00
|
|
|
{ return *this; }
|
|
|
|
|
};
|
|
|
|
|
|
2017-12-17 15:41:56 +01:00
|
|
|
// for QMap / QHash, inserting a std::pair / QPair
|
|
|
|
|
template <class Container>
|
|
|
|
|
class MapInsertIterator :
|
|
|
|
|
public std::iterator<std::output_iterator_tag,void,void,void,void>
|
|
|
|
|
{
|
|
|
|
|
protected:
|
|
|
|
|
Container *container;
|
|
|
|
|
|
|
|
|
|
public:
|
2018-07-23 10:45:40 +02:00
|
|
|
using container_type = Container;
|
2017-12-17 15:41:56 +01:00
|
|
|
explicit MapInsertIterator (Container &x)
|
|
|
|
|
: container(&x) {}
|
|
|
|
|
MapInsertIterator<Container> &operator=(const std::pair<const typename Container::key_type, typename Container::mapped_type> &value)
|
|
|
|
|
{ container->insert(value.first, value.second); return *this; }
|
|
|
|
|
MapInsertIterator<Container> &operator=(const QPair<typename Container::key_type, typename Container::mapped_type> &value)
|
|
|
|
|
{ container->insert(value.first, value.second); return *this; }
|
|
|
|
|
MapInsertIterator<Container >&operator*()
|
|
|
|
|
{ return *this; }
|
|
|
|
|
MapInsertIterator<Container> &operator++()
|
|
|
|
|
{ return *this; }
|
|
|
|
|
MapInsertIterator<Container> operator++(int)
|
|
|
|
|
{ return *this; }
|
|
|
|
|
};
|
|
|
|
|
|
2014-10-30 15:42:42 +01:00
|
|
|
// inserter helper function, returns a std::back_inserter for most containers
|
2017-12-15 13:52:47 +01:00
|
|
|
// and is overloaded for QSet<> and other containers without push_back, returning custom inserters
|
2014-10-30 15:42:42 +01:00
|
|
|
template<typename C>
|
|
|
|
|
inline std::back_insert_iterator<C>
|
|
|
|
|
inserter(C &container)
|
|
|
|
|
{
|
|
|
|
|
return std::back_inserter(container);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename X>
|
2017-12-15 13:52:47 +01:00
|
|
|
inline SetInsertIterator<QSet<X>>
|
2014-10-30 15:42:42 +01:00
|
|
|
inserter(QSet<X> &container)
|
|
|
|
|
{
|
2017-12-15 13:52:47 +01:00
|
|
|
return SetInsertIterator<QSet<X>>(container);
|
2014-10-30 15:42:42 +01:00
|
|
|
}
|
|
|
|
|
|
2017-12-15 13:52:47 +01:00
|
|
|
template<typename K, typename C, typename A>
|
|
|
|
|
inline SetInsertIterator<std::set<K, C, A>>
|
|
|
|
|
inserter(std::set<K, C, A> &container)
|
|
|
|
|
{
|
|
|
|
|
return SetInsertIterator<std::set<K, C, A>>(container);
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-17 15:41:56 +01:00
|
|
|
template<typename K, typename H, typename C, typename A>
|
|
|
|
|
inline SetInsertIterator<std::unordered_set<K, H, C, A>>
|
|
|
|
|
inserter(std::unordered_set<K, H, C, A> &container)
|
|
|
|
|
{
|
|
|
|
|
return SetInsertIterator<std::unordered_set<K, H, C, A>>(container);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename K, typename V, typename C, typename A>
|
|
|
|
|
inline SetInsertIterator<std::map<K, V, C, A>>
|
|
|
|
|
inserter(std::map<K, V, C, A> &container)
|
|
|
|
|
{
|
|
|
|
|
return SetInsertIterator<std::map<K, V, C, A>>(container);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename K, typename V, typename H, typename C, typename A>
|
|
|
|
|
inline SetInsertIterator<std::unordered_map<K, V, H, C, A>>
|
|
|
|
|
inserter(std::unordered_map<K, V, H, C, A> &container)
|
|
|
|
|
{
|
|
|
|
|
return SetInsertIterator<std::unordered_map<K, V, H, C, A>>(container);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename K, typename V>
|
|
|
|
|
inline MapInsertIterator<QMap<K, V>>
|
|
|
|
|
inserter(QMap<K, V> &container)
|
|
|
|
|
{
|
|
|
|
|
return MapInsertIterator<QMap<K, V>>(container);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename K, typename V>
|
|
|
|
|
inline MapInsertIterator<QHash<K, V>>
|
|
|
|
|
inserter(QHash<K, V> &container)
|
|
|
|
|
{
|
|
|
|
|
return MapInsertIterator<QHash<K, V>>(container);
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-15 13:52:47 +01:00
|
|
|
// Helper code for container.reserve that makes it possible to effectively disable it for
|
|
|
|
|
// specific cases
|
|
|
|
|
|
|
|
|
|
// default: do reserve
|
|
|
|
|
// Template arguments are more specific than the second version below, so this is tried first
|
|
|
|
|
template<template<typename...> class C, typename... CArgs,
|
|
|
|
|
typename = decltype(&C<CArgs...>::reserve)>
|
|
|
|
|
void reserve(C<CArgs...> &c, typename C<CArgs...>::size_type s)
|
|
|
|
|
{
|
|
|
|
|
c.reserve(s);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// containers that don't have reserve()
|
|
|
|
|
template<typename C>
|
|
|
|
|
void reserve(C &, typename C::size_type) { }
|
|
|
|
|
|
2016-07-12 13:38:42 +02:00
|
|
|
} // anonymous
|
2016-12-01 12:24:42 +01:00
|
|
|
|
2017-11-29 15:50:11 +01:00
|
|
|
// --------------------------------------------------------------------
|
|
|
|
|
// Different containers for input and output:
|
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
|
|
2016-07-12 13:38:42 +02:00
|
|
|
// different container types for input and output, e.g. transforming a QList into a QSet
|
2017-11-29 15:50:11 +01:00
|
|
|
|
2017-12-11 20:35:39 +01:00
|
|
|
// function without result type deduction:
|
|
|
|
|
template<typename ResultContainer, // complete result container type
|
2017-12-16 20:39:33 +01:00
|
|
|
typename SC, // input container type
|
|
|
|
|
typename F> // function type
|
2016-07-12 13:38:42 +02:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-16 20:39:33 +01:00
|
|
|
decltype(auto) transform(SC &&container, F function)
|
2016-07-12 13:38:42 +02:00
|
|
|
{
|
2017-12-06 16:42:06 +01:00
|
|
|
ResultContainer result;
|
2018-05-03 11:40:19 +02:00
|
|
|
reserve(result, typename ResultContainer::size_type(container.size()));
|
2017-12-06 16:42:06 +01:00
|
|
|
std::transform(std::begin(container), std::end(container), inserter(result), function);
|
2016-07-12 13:38:42 +02:00
|
|
|
return result;
|
2016-07-12 13:38:42 +02:00
|
|
|
}
|
2014-11-05 11:45:40 +03:00
|
|
|
|
2017-12-11 20:35:39 +01:00
|
|
|
// function with result type deduction:
|
|
|
|
|
template<template<typename> class C, // result container type
|
2019-05-13 14:26:11 +02:00
|
|
|
typename SC, // input container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename Value,
|
|
|
|
|
typename Result,
|
|
|
|
|
typename ResultContainer>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, F function)
|
2017-12-11 20:35:39 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<ResultContainer>(std::forward<SC>(container), function);
|
2017-12-11 20:35:39 +01:00
|
|
|
}
|
|
|
|
|
|
2017-12-06 17:25:24 +01:00
|
|
|
template<template<typename, typename> class C, // result container type
|
2019-05-13 14:26:11 +02:00
|
|
|
typename SC, // input container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename Value,
|
|
|
|
|
typename Result,
|
|
|
|
|
typename ResultContainer>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) transform(SC &&container, F function)
|
2017-12-06 17:25:24 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<ResultContainer>(std::forward<SC>(container), function);
|
2017-12-06 17:25:24 +01:00
|
|
|
}
|
|
|
|
|
|
2017-12-11 20:35:39 +01:00
|
|
|
// member function without result type deduction:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C, // result container type
|
2017-12-16 20:39:33 +01:00
|
|
|
typename SC, // input container type
|
2016-07-12 13:38:42 +02:00
|
|
|
typename R,
|
2017-12-16 20:39:33 +01:00
|
|
|
typename S>
|
2016-07-12 13:38:42 +02:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-16 20:39:33 +01:00
|
|
|
decltype(auto) transform(SC &&container, R (S::*p)() const)
|
2016-07-12 13:38:42 +02:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C>(std::forward<SC>(container), std::mem_fn(p));
|
2016-07-12 13:38:42 +02:00
|
|
|
}
|
2016-12-01 12:24:42 +01:00
|
|
|
|
2017-12-11 20:35:39 +01:00
|
|
|
// member function with result type deduction:
|
|
|
|
|
template<typename ResultContainer, // complete result container type
|
2017-12-16 20:39:33 +01:00
|
|
|
typename SC, // input container type
|
2017-12-11 20:35:39 +01:00
|
|
|
typename R,
|
2017-12-16 20:39:33 +01:00
|
|
|
typename S>
|
2017-12-11 20:35:39 +01:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-16 20:39:33 +01:00
|
|
|
decltype(auto) transform(SC &&container, R (S::*p)() const)
|
2017-12-11 20:35:39 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<ResultContainer>(std::forward<SC>(container), std::mem_fn(p));
|
2017-12-11 20:35:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// member without result type deduction:
|
|
|
|
|
template<typename ResultContainer, // complete result container type
|
2017-12-16 20:39:33 +01:00
|
|
|
typename SC, // input container
|
2017-12-11 20:35:39 +01:00
|
|
|
typename R,
|
2017-12-16 20:39:33 +01:00
|
|
|
typename S>
|
2017-12-11 20:35:39 +01:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-16 20:39:33 +01:00
|
|
|
decltype(auto) transform(SC &&container, R S::*p)
|
2017-12-11 20:35:39 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<ResultContainer>(std::forward<SC>(container), std::mem_fn(p));
|
2017-12-11 20:35:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// member with result type deduction:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C, // result container
|
2017-12-16 20:39:33 +01:00
|
|
|
typename SC, // input container
|
2017-11-29 15:50:11 +01:00
|
|
|
typename R,
|
2017-12-16 20:39:33 +01:00
|
|
|
typename S>
|
2014-06-04 13:11:25 +02:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-16 20:39:33 +01:00
|
|
|
decltype(auto) transform(SC &&container, R S::*p)
|
2014-06-04 13:11:25 +02:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C>(std::forward<SC>(container), std::mem_fn(p));
|
2014-06-04 13:11:25 +02:00
|
|
|
}
|
|
|
|
|
|
2017-12-16 20:39:33 +01:00
|
|
|
// same container types for input and output, const input
|
2017-11-29 15:50:11 +01:00
|
|
|
|
|
|
|
|
// function:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C, // container type
|
2017-11-29 15:50:11 +01:00
|
|
|
typename F, // function type
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT
|
2017-12-06 16:42:06 +01:00
|
|
|
decltype(auto) transform(const C<CArgs...> &container, F function)
|
2017-11-29 15:50:11 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C, const C<CArgs...> &>(container, function);
|
2017-11-29 15:50:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// member function:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C, // container type
|
2016-07-12 13:38:42 +02:00
|
|
|
typename R,
|
2017-11-29 15:50:11 +01:00
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
2014-10-30 15:42:42 +01:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-06 16:42:06 +01:00
|
|
|
decltype(auto) transform(const C<CArgs...> &container, R (S::*p)() const)
|
2014-10-30 15:42:42 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C, const C<CArgs...> &>(container, std::mem_fn(p));
|
2014-10-30 15:42:42 +01:00
|
|
|
}
|
|
|
|
|
|
2017-11-29 15:50:11 +01:00
|
|
|
// members:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C, // container
|
2017-03-09 22:11:11 +02:00
|
|
|
typename R,
|
2017-11-29 15:50:11 +01:00
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
2017-03-09 22:11:11 +02:00
|
|
|
Q_REQUIRED_RESULT
|
2017-12-06 16:42:06 +01:00
|
|
|
decltype(auto) transform(const C<CArgs...> &container, R S::*p)
|
2017-03-09 22:11:11 +02:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C, const C<CArgs...> &>(container, std::mem_fn(p));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// same container types for input and output, non-const input
|
|
|
|
|
|
|
|
|
|
// function:
|
|
|
|
|
template<template<typename...> class C, // container type
|
|
|
|
|
typename F, // function type
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
decltype(auto) transform(C<CArgs...> &container, F function)
|
|
|
|
|
{
|
|
|
|
|
return transform<C, C<CArgs...> &>(container, function);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// member function:
|
|
|
|
|
template<template<typename...> class C, // container type
|
|
|
|
|
typename R,
|
|
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
decltype(auto) transform(C<CArgs...> &container, R (S::*p)() const)
|
|
|
|
|
{
|
|
|
|
|
return transform<C, C<CArgs...> &>(container, std::mem_fn(p));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// members:
|
|
|
|
|
template<template<typename...> class C, // container
|
|
|
|
|
typename R,
|
|
|
|
|
typename S,
|
|
|
|
|
typename... CArgs> // Arguments to SC
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
decltype(auto) transform(C<CArgs...> &container, R S::*p)
|
|
|
|
|
{
|
|
|
|
|
return transform<C, C<CArgs...> &>(container, std::mem_fn(p));
|
2017-03-09 22:11:11 +02:00
|
|
|
}
|
|
|
|
|
|
2017-11-29 15:50:11 +01:00
|
|
|
// Specialization for QStringList:
|
|
|
|
|
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C = QList, // result container
|
2017-11-29 15:50:11 +01:00
|
|
|
typename F> // Arguments to C
|
2014-10-30 15:42:42 +01:00
|
|
|
Q_REQUIRED_RESULT
|
2016-07-12 13:38:42 +02:00
|
|
|
decltype(auto) transform(const QStringList &container, F function)
|
2014-10-30 15:42:42 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C, const QList<QString> &>(static_cast<QList<QString>>(container), function);
|
2014-10-30 15:42:42 +01:00
|
|
|
}
|
|
|
|
|
|
2017-11-29 15:50:11 +01:00
|
|
|
// member function:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C = QList, // result container type
|
2017-11-29 15:50:11 +01:00
|
|
|
typename R,
|
|
|
|
|
typename S>
|
2014-10-30 15:42:42 +01:00
|
|
|
Q_REQUIRED_RESULT
|
2017-11-29 15:50:11 +01:00
|
|
|
decltype(auto) transform(const QStringList &container, R (S::*p)() const)
|
2014-10-30 15:42:42 +01:00
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C, const QList<QString> &>(static_cast<QList<QString>>(container), std::mem_fn(p));
|
2017-11-29 15:50:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// members:
|
2017-12-06 16:42:06 +01:00
|
|
|
template<template<typename...> class C = QList, // result container
|
2017-11-29 15:50:11 +01:00
|
|
|
typename R,
|
|
|
|
|
typename S>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
decltype(auto) transform(const QStringList &container, R S::*p)
|
|
|
|
|
{
|
2017-12-16 20:39:33 +01:00
|
|
|
return transform<C, const QList<QString> &>(static_cast<QList<QString>>(container), std::mem_fn(p));
|
2014-10-30 15:42:42 +01:00
|
|
|
}
|
|
|
|
|
|
2015-10-14 13:15:09 +02:00
|
|
|
//////////////////
|
|
|
|
|
// filtered
|
|
|
|
|
/////////////////
|
|
|
|
|
template<typename C, typename F>
|
2015-10-21 14:42:54 +02:00
|
|
|
Q_REQUIRED_RESULT
|
2015-10-14 13:15:09 +02:00
|
|
|
C filtered(const C &container, F predicate)
|
|
|
|
|
{
|
2015-10-27 11:01:03 +01:00
|
|
|
C out;
|
2017-11-27 11:31:15 +01:00
|
|
|
std::copy_if(std::begin(container), std::end(container),
|
2015-10-27 11:01:03 +01:00
|
|
|
inserter(out), predicate);
|
|
|
|
|
return out;
|
2015-10-14 13:15:09 +02:00
|
|
|
}
|
|
|
|
|
|
2015-10-23 12:42:23 +02:00
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
C filtered(const C &container, R (S::*predicate)() const)
|
|
|
|
|
{
|
2015-10-27 11:01:03 +01:00
|
|
|
C out;
|
2017-11-27 11:31:15 +01:00
|
|
|
std::copy_if(std::begin(container), std::end(container),
|
2015-10-27 11:01:03 +01:00
|
|
|
inserter(out), std::mem_fn(predicate));
|
|
|
|
|
return out;
|
2015-10-23 12:42:23 +02:00
|
|
|
}
|
|
|
|
|
|
2015-10-27 11:01:34 +01:00
|
|
|
//////////////////
|
|
|
|
|
// partition
|
|
|
|
|
/////////////////
|
|
|
|
|
|
|
|
|
|
// Recommended usage:
|
|
|
|
|
// C hit;
|
|
|
|
|
// C miss;
|
|
|
|
|
// std::tie(hit, miss) = Utils::partition(container, predicate);
|
|
|
|
|
|
|
|
|
|
template<typename C, typename F>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
std::tuple<C, C> partition(const C &container, F predicate)
|
|
|
|
|
{
|
|
|
|
|
C hit;
|
|
|
|
|
C miss;
|
|
|
|
|
auto hitIns = inserter(hit);
|
|
|
|
|
auto missIns = inserter(miss);
|
2017-02-04 23:08:39 +02:00
|
|
|
for (auto i : container) {
|
2015-10-27 11:01:34 +01:00
|
|
|
if (predicate(i))
|
|
|
|
|
hitIns = i;
|
|
|
|
|
else
|
|
|
|
|
missIns = i;
|
|
|
|
|
}
|
|
|
|
|
return std::make_tuple(hit, miss);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
std::tuple<C, C> partition(const C &container, R (S::*predicate)() const)
|
|
|
|
|
{
|
|
|
|
|
return partition(container, std::mem_fn(predicate));
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-03 13:51:47 +01:00
|
|
|
//////////////////
|
|
|
|
|
// filteredUnique
|
|
|
|
|
/////////////////
|
|
|
|
|
|
|
|
|
|
template<typename C>
|
|
|
|
|
Q_REQUIRED_RESULT
|
|
|
|
|
C filteredUnique(const C &container)
|
|
|
|
|
{
|
|
|
|
|
C result;
|
|
|
|
|
auto ins = inserter(result);
|
|
|
|
|
|
|
|
|
|
QSet<typename C::value_type> seen;
|
|
|
|
|
int setSize = 0;
|
|
|
|
|
|
2017-11-27 11:31:15 +01:00
|
|
|
auto endIt = std::end(container);
|
|
|
|
|
for (auto it = std::begin(container); it != endIt; ++it) {
|
2015-11-03 13:51:47 +01:00
|
|
|
seen.insert(*it);
|
|
|
|
|
if (setSize == seen.size()) // unchanged size => was already seen
|
|
|
|
|
continue;
|
|
|
|
|
++setSize;
|
|
|
|
|
ins = *it;
|
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-14 09:26:38 +01:00
|
|
|
//////////////////
|
|
|
|
|
// qobject_container_cast
|
|
|
|
|
/////////////////
|
|
|
|
|
template <class T, template<typename> class Container, typename Base>
|
|
|
|
|
Container<T> qobject_container_cast(const Container<Base> &container)
|
|
|
|
|
{
|
|
|
|
|
Container<T> result;
|
|
|
|
|
auto ins = inserter(result);
|
|
|
|
|
for (Base val : container) {
|
|
|
|
|
if (T target = qobject_cast<T>(val))
|
|
|
|
|
ins = target;
|
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-29 10:59:27 +02:00
|
|
|
//////////////////
|
|
|
|
|
// static_container_cast
|
|
|
|
|
/////////////////
|
|
|
|
|
template <class T, template<typename> class Container, typename Base>
|
|
|
|
|
Container<T> static_container_cast(const Container<Base> &container)
|
|
|
|
|
{
|
|
|
|
|
Container<T> result;
|
|
|
|
|
reserve(result, container.size());
|
|
|
|
|
auto ins = inserter(result);
|
|
|
|
|
for (Base val : container)
|
|
|
|
|
ins = static_cast<T>(val);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-07 19:02:26 +02:00
|
|
|
//////////////////
|
|
|
|
|
// sort
|
|
|
|
|
/////////////////
|
2014-06-16 18:25:52 +04:00
|
|
|
template <typename Container>
|
2017-11-27 11:31:15 +01:00
|
|
|
inline void sort(Container &container)
|
2014-06-16 18:25:52 +04:00
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
std::sort(std::begin(container), std::end(container));
|
2014-06-16 18:25:52 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename Container, typename Predicate>
|
2017-11-27 11:31:15 +01:00
|
|
|
inline void sort(Container &container, Predicate p)
|
2014-06-16 18:25:52 +04:00
|
|
|
{
|
2017-11-27 11:31:15 +01:00
|
|
|
std::sort(std::begin(container), std::end(container), p);
|
2014-06-16 18:25:52 +04:00
|
|
|
}
|
|
|
|
|
|
2016-08-03 22:55:07 +03:00
|
|
|
// pointer to member
|
|
|
|
|
template <typename Container, typename R, typename S>
|
2017-11-27 11:31:15 +01:00
|
|
|
inline void sort(Container &container, R S::*member)
|
2016-08-03 22:55:07 +03:00
|
|
|
{
|
2016-08-09 14:36:10 +02:00
|
|
|
auto f = std::mem_fn(member);
|
|
|
|
|
using const_ref = typename Container::const_reference;
|
2017-11-27 11:31:15 +01:00
|
|
|
std::sort(std::begin(container), std::end(container),
|
|
|
|
|
[&f](const_ref a, const_ref b) {
|
2016-08-09 14:36:10 +02:00
|
|
|
return f(a) < f(b);
|
2016-08-03 22:55:07 +03:00
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// pointer to member function
|
|
|
|
|
template <typename Container, typename R, typename S>
|
2017-11-27 11:31:15 +01:00
|
|
|
inline void sort(Container &container, R (S::*function)() const)
|
2016-08-03 22:55:07 +03:00
|
|
|
{
|
2016-08-09 14:36:10 +02:00
|
|
|
auto f = std::mem_fn(function);
|
|
|
|
|
using const_ref = typename Container::const_reference;
|
2017-11-27 11:31:15 +01:00
|
|
|
std::sort(std::begin(container), std::end(container),
|
|
|
|
|
[&f](const_ref a, const_ref b) {
|
2016-08-09 14:36:10 +02:00
|
|
|
return f(a) < f(b);
|
2016-08-03 22:55:07 +03:00
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-22 16:41:55 +02:00
|
|
|
//////////////////
|
|
|
|
|
// reverseForeach
|
|
|
|
|
/////////////////
|
|
|
|
|
template <typename Container, typename Op>
|
|
|
|
|
inline void reverseForeach(const Container &c, const Op &operation)
|
|
|
|
|
{
|
|
|
|
|
auto rend = c.rend();
|
|
|
|
|
for (auto it = c.rbegin(); it != rend; ++it)
|
|
|
|
|
operation(*it);
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-28 17:58:24 +01:00
|
|
|
//////////////////
|
|
|
|
|
// toReferences
|
|
|
|
|
/////////////////
|
|
|
|
|
template <template<typename...> class ResultContainer,
|
|
|
|
|
typename SourceContainer>
|
|
|
|
|
auto toReferences(SourceContainer &sources)
|
|
|
|
|
{
|
|
|
|
|
return transform<ResultContainer>(sources, [] (auto &value) { return std::ref(value); });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename SourceContainer>
|
|
|
|
|
auto toReferences(SourceContainer &sources)
|
|
|
|
|
{
|
|
|
|
|
return transform(sources, [] (auto &value) { return std::ref(value); });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////
|
|
|
|
|
// toConstReferences
|
|
|
|
|
/////////////////
|
|
|
|
|
template <template<typename...> class ResultContainer,
|
|
|
|
|
typename SourceContainer>
|
|
|
|
|
auto toConstReferences(const SourceContainer &sources)
|
|
|
|
|
{
|
|
|
|
|
return transform<ResultContainer>(sources, [] (const auto &value) { return std::cref(value); });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename SourceContainer>
|
|
|
|
|
auto toConstReferences(const SourceContainer &sources)
|
|
|
|
|
{
|
|
|
|
|
return transform(sources, [] (const auto &value) { return std::cref(value); });
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-09 15:32:47 +01:00
|
|
|
//////////////////
|
|
|
|
|
// take:
|
|
|
|
|
/////////////////
|
|
|
|
|
|
|
|
|
|
template<class C, typename P>
|
2018-07-17 23:21:05 +03:00
|
|
|
Q_REQUIRED_RESULT optional<typename C::value_type> take(C &container, P predicate)
|
2018-01-09 15:32:47 +01:00
|
|
|
{
|
|
|
|
|
const auto end = std::end(container);
|
|
|
|
|
|
|
|
|
|
const auto it = std::find_if(std::begin(container), end, predicate);
|
|
|
|
|
if (it == end)
|
2018-07-17 23:21:05 +03:00
|
|
|
return nullopt;
|
2018-01-09 15:32:47 +01:00
|
|
|
|
2018-07-17 23:21:05 +03:00
|
|
|
optional<typename C::value_type> result = Utils::make_optional(std::move(*it));
|
2018-01-09 15:32:47 +01:00
|
|
|
container.erase(it);
|
|
|
|
|
return result;
|
2014-06-04 13:11:25 +02:00
|
|
|
}
|
2018-01-09 15:32:47 +01:00
|
|
|
|
|
|
|
|
// pointer to member
|
|
|
|
|
template <typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) take(C &container, R S::*member)
|
|
|
|
|
{
|
|
|
|
|
return take(container, std::mem_fn(member));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// pointer to member function
|
|
|
|
|
template <typename C, typename R, typename S>
|
|
|
|
|
Q_REQUIRED_RESULT decltype(auto) take(C &container, R (S::*function)() const)
|
|
|
|
|
{
|
|
|
|
|
return take(container, std::mem_fn(function));
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-27 11:12:42 +02:00
|
|
|
//////////////////
|
|
|
|
|
// setUnionMerge: Works like std::set_union but provides a merge function for items that match
|
|
|
|
|
// !(a > b) && !(b > a) which normally means that there is an "equal" match.
|
|
|
|
|
// It uses iterators to support move_iterators.
|
|
|
|
|
/////////////////
|
|
|
|
|
|
|
|
|
|
template<class InputIt1,
|
|
|
|
|
class InputIt2,
|
|
|
|
|
class OutputIt,
|
|
|
|
|
class Merge,
|
|
|
|
|
class Compare>
|
|
|
|
|
OutputIt setUnionMerge(InputIt1 first1,
|
|
|
|
|
InputIt1 last1,
|
|
|
|
|
InputIt2 first2,
|
|
|
|
|
InputIt2 last2,
|
|
|
|
|
OutputIt d_first,
|
|
|
|
|
Merge merge,
|
|
|
|
|
Compare comp)
|
|
|
|
|
{
|
|
|
|
|
for (; first1 != last1; ++d_first) {
|
|
|
|
|
if (first2 == last2)
|
|
|
|
|
return std::copy(first1, last1, d_first);
|
|
|
|
|
if (comp(*first2, *first1)) {
|
|
|
|
|
*d_first = *first2++;
|
|
|
|
|
} else {
|
|
|
|
|
if (comp(*first1, *first2)) {
|
|
|
|
|
*d_first = *first1;
|
|
|
|
|
} else {
|
|
|
|
|
*d_first = merge(*first1, *first2);
|
|
|
|
|
++first2;
|
|
|
|
|
}
|
|
|
|
|
++first1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return std::copy(first2, last2, d_first);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class InputIt1,
|
|
|
|
|
class InputIt2,
|
|
|
|
|
class OutputIt,
|
|
|
|
|
class Merge>
|
|
|
|
|
OutputIt setUnionMerge(InputIt1 first1,
|
|
|
|
|
InputIt1 last1,
|
|
|
|
|
InputIt2 first2,
|
|
|
|
|
InputIt2 last2,
|
|
|
|
|
OutputIt d_first,
|
|
|
|
|
Merge merge)
|
|
|
|
|
{
|
|
|
|
|
return setUnionMerge(first1,
|
|
|
|
|
last1,
|
|
|
|
|
first2,
|
|
|
|
|
last2,
|
|
|
|
|
d_first,
|
|
|
|
|
merge,
|
2018-08-30 14:13:23 +02:00
|
|
|
std::less<std::decay_t<decltype(*first1)>>{});
|
2018-08-27 11:12:42 +02:00
|
|
|
}
|
|
|
|
|
|
2018-08-28 12:26:50 +02:00
|
|
|
template<class OutputContainer,
|
|
|
|
|
class InputContainer1,
|
|
|
|
|
class InputContainer2,
|
|
|
|
|
class Merge,
|
|
|
|
|
class Compare>
|
|
|
|
|
OutputContainer setUnionMerge(InputContainer1 &&input1,
|
|
|
|
|
InputContainer2 &&input2,
|
|
|
|
|
Merge merge,
|
|
|
|
|
Compare comp)
|
|
|
|
|
{
|
|
|
|
|
OutputContainer results;
|
|
|
|
|
results.reserve(input1.size() + input2.size());
|
|
|
|
|
|
|
|
|
|
setUnionMerge(std::make_move_iterator(std::begin(input1)),
|
|
|
|
|
std::make_move_iterator(std::end(input1)),
|
|
|
|
|
std::make_move_iterator(std::begin(input2)),
|
|
|
|
|
std::make_move_iterator(std::end(input2)),
|
|
|
|
|
std::back_inserter(results),
|
|
|
|
|
merge,
|
|
|
|
|
comp);
|
|
|
|
|
|
|
|
|
|
return results;
|
|
|
|
|
}
|
2018-08-27 11:12:42 +02:00
|
|
|
|
2018-08-28 12:26:50 +02:00
|
|
|
template<class OutputContainer,
|
|
|
|
|
class InputContainer1,
|
|
|
|
|
class InputContainer2,
|
|
|
|
|
class Merge>
|
|
|
|
|
OutputContainer setUnionMerge(InputContainer1 &&input1,
|
|
|
|
|
InputContainer2 &&input2,
|
|
|
|
|
Merge merge)
|
|
|
|
|
{
|
2018-08-30 14:13:23 +02:00
|
|
|
return setUnionMerge<OutputContainer>(std::forward<InputContainer1>(input1),
|
|
|
|
|
std::forward<InputContainer2>(input2),
|
|
|
|
|
merge,
|
|
|
|
|
std::less<std::decay_t<decltype(*std::begin(input1))>>{});
|
2018-08-28 12:26:50 +02:00
|
|
|
}
|
2019-01-09 18:29:56 +01:00
|
|
|
|
|
|
|
|
template<typename Container>
|
|
|
|
|
std::make_unsigned_t<typename Container::size_type> usize(Container container)
|
|
|
|
|
{
|
|
|
|
|
return static_cast<std::make_unsigned_t<typename Container::size_type>>(container.size());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename Container>
|
|
|
|
|
std::make_signed_t<typename Container::size_type> ssize(Container container)
|
|
|
|
|
{
|
|
|
|
|
return static_cast<std::make_signed_t<typename Container::size_type>>(container.size());
|
|
|
|
|
}
|
2019-04-02 18:29:13 +02:00
|
|
|
|
|
|
|
|
template<typename Compare>
|
|
|
|
|
struct CompareIter
|
|
|
|
|
{
|
|
|
|
|
Compare compare;
|
|
|
|
|
|
|
|
|
|
explicit constexpr CompareIter(Compare compare)
|
|
|
|
|
: compare(std::move(compare))
|
|
|
|
|
{}
|
|
|
|
|
|
|
|
|
|
template<typename Iterator1, typename Iterator2>
|
|
|
|
|
constexpr bool operator()(Iterator1 it1, Iterator2 it2)
|
|
|
|
|
{
|
|
|
|
|
return bool(compare(*it1, *it2));
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
|
|
|
|
|
OutputIterator set_union_impl(InputIterator1 first1,
|
|
|
|
|
InputIterator1 last1,
|
|
|
|
|
InputIterator2 first2,
|
|
|
|
|
InputIterator2 last2,
|
|
|
|
|
OutputIterator result,
|
|
|
|
|
Compare comp)
|
|
|
|
|
{
|
|
|
|
|
auto compare = CompareIter<Compare>(comp);
|
|
|
|
|
|
|
|
|
|
while (first1 != last1 && first2 != last2) {
|
|
|
|
|
if (compare(first1, first2)) {
|
|
|
|
|
*result = *first1;
|
|
|
|
|
++first1;
|
|
|
|
|
} else if (compare(first2, first1)) {
|
|
|
|
|
*result = *first2;
|
|
|
|
|
++first2;
|
|
|
|
|
} else {
|
|
|
|
|
*result = *first1;
|
|
|
|
|
++first1;
|
|
|
|
|
++first2;
|
|
|
|
|
}
|
|
|
|
|
++result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return std::copy(first2, last2, std::copy(first1, last1, result));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
|
|
|
|
|
OutputIterator set_union(InputIterator1 first1,
|
|
|
|
|
InputIterator1 last1,
|
|
|
|
|
InputIterator2 first2,
|
|
|
|
|
InputIterator2 last2,
|
|
|
|
|
OutputIterator result,
|
|
|
|
|
Compare comp)
|
|
|
|
|
{
|
|
|
|
|
return Utils::set_union_impl(first1, last1, first2, last2, result, comp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
|
|
|
|
|
OutputIterator set_union(InputIterator1 first1,
|
|
|
|
|
InputIterator1 last1,
|
|
|
|
|
InputIterator2 first2,
|
|
|
|
|
InputIterator2 last2,
|
|
|
|
|
OutputIterator result)
|
|
|
|
|
{
|
|
|
|
|
return Utils::set_union_impl(
|
|
|
|
|
first1, last1, first2, last2, result, std::less<typename InputIterator1::value_type>{});
|
|
|
|
|
}
|
2019-06-21 08:40:47 +02:00
|
|
|
|
|
|
|
|
// Replacement for deprecated Qt functionality
|
|
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
|
QSet<T> toSet(const QList<T> &list)
|
|
|
|
|
{
|
2019-07-03 15:16:07 +02:00
|
|
|
#if (QT_VERSION <= QT_VERSION_CHECK(5, 13, 0))
|
2019-06-21 08:40:47 +02:00
|
|
|
return list.toSet();
|
|
|
|
|
#else
|
2019-07-03 15:16:07 +02:00
|
|
|
return QSet<T>(list.begin(), list.end());
|
2019-06-21 08:40:47 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
|
QList<T> toList(const QSet<T> &set)
|
|
|
|
|
{
|
2019-07-03 15:16:07 +02:00
|
|
|
#if (QT_VERSION <= QT_VERSION_CHECK(5, 13, 0))
|
2019-06-21 08:40:47 +02:00
|
|
|
return set.toList();
|
|
|
|
|
#else
|
2019-07-03 15:16:07 +02:00
|
|
|
return QList<T>(set.begin(), set.end());
|
2019-06-21 08:40:47 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-09 15:32:47 +01:00
|
|
|
} // namespace Utils
|
