diff options
Diffstat (limited to 'tests/auto/concurrent/qtconcurrentfiltermapgenerated/generation_helpers.h')
-rw-r--r-- | tests/auto/concurrent/qtconcurrentfiltermapgenerated/generation_helpers.h | 265 |
1 files changed, 265 insertions, 0 deletions
diff --git a/tests/auto/concurrent/qtconcurrentfiltermapgenerated/generation_helpers.h b/tests/auto/concurrent/qtconcurrentfiltermapgenerated/generation_helpers.h new file mode 100644 index 0000000000..aaa0d85002 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentfiltermapgenerated/generation_helpers.h @@ -0,0 +1,265 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#ifndef QTBASE_GENERATION_HELPERS_H +#define QTBASE_GENERATION_HELPERS_H + +#include "qglobal.h" + +#include <vector> + +struct tag_input +{ +}; +struct tag_mapped +{ +}; +struct tag_reduction +{ +}; + +template<typename tag> +struct SequenceItem +{ + SequenceItem() = default; + // bool as a stronger "explicit": should never be called inside of QtConcurrent + SequenceItem(int val, bool) : value(val) { } + + bool operator==(const SequenceItem<tag> &other) const { return value == other.value; } + bool isOdd() const { return value & 1; } + void multiplyByTwo() { value *= 2; } + + int value = 0; +}; + +template<typename tag> +struct NoConstructSequenceItem +{ + NoConstructSequenceItem() = delete; + // bool as a stronger "explicit": should never be called inside of QtConcurrent + NoConstructSequenceItem(int val, bool) : value(val) { } + + bool operator==(const NoConstructSequenceItem<tag> &other) const + { + return value == other.value; + } + bool isOdd() const { return value & 1; } + void multiplyByTwo() { value *= 2; } + + int value = 0; +}; + +template<typename tag> +struct MoveOnlySequenceItem +{ + MoveOnlySequenceItem() = default; + ~MoveOnlySequenceItem() = default; + MoveOnlySequenceItem(const MoveOnlySequenceItem &) = delete; + MoveOnlySequenceItem(MoveOnlySequenceItem &&other) : value(other.value) { other.value = -1; } + MoveOnlySequenceItem &operator=(const MoveOnlySequenceItem &) = delete; + MoveOnlySequenceItem &operator=(MoveOnlySequenceItem &&other) + { + value = other.value; + other.value = -1; + } + + // bool as a stronger "explicit": should never be called inside of QtConcurrent + MoveOnlySequenceItem(int val, bool) : value(val) { } + + bool operator==(const MoveOnlySequenceItem<tag> &other) const { return value == other.value; } + bool isOdd() const { return value & 1; } + void multiplyByTwo() { value *= 2; } + + int value = 0; +}; + +template<typename tag> +struct MoveOnlyNoConstructSequenceItem +{ + MoveOnlyNoConstructSequenceItem() = delete; + ~MoveOnlyNoConstructSequenceItem() = default; + MoveOnlyNoConstructSequenceItem(const MoveOnlyNoConstructSequenceItem &) = delete; + MoveOnlyNoConstructSequenceItem(MoveOnlyNoConstructSequenceItem &&other) : value(other.value) + { + other.value = -1; + } + MoveOnlyNoConstructSequenceItem &operator=(const MoveOnlyNoConstructSequenceItem &) = delete; + MoveOnlyNoConstructSequenceItem &operator=(MoveOnlyNoConstructSequenceItem &&other) + { + value = other.value; + other.value = -1; + } + + // bool as a stronger "explicit": should never be called inside of QtConcurrent + MoveOnlyNoConstructSequenceItem(int val, bool) : value(val) { } + + bool operator==(const MoveOnlyNoConstructSequenceItem<tag> &other) const + { + return value == other.value; + } + bool isOdd() const { return value & 1; } + void multiplyByTwo() { value *= 2; } + + int value = 0; +}; + +template<typename T> +bool myfilter(const T &el) +{ + return el.isOdd(); +} + +template<typename T> +class MyFilter +{ +public: + bool operator()(const T &el) { return el.isOdd(); } +}; + +template<typename T> +class MyMoveOnlyFilter +{ + bool movedFrom = false; + +public: + MyMoveOnlyFilter() = default; + MyMoveOnlyFilter(const MyMoveOnlyFilter<T> &) = delete; + MyMoveOnlyFilter &operator=(const MyMoveOnlyFilter<T> &) = delete; + + MyMoveOnlyFilter(MyMoveOnlyFilter<T> &&other) { other.movedFrom = true; } + MyMoveOnlyFilter &operator=(MyMoveOnlyFilter<T> &&other) { other.movedFrom = true; } + + bool operator()(const T &el) + { + return movedFrom || el.isOdd(); + } +}; + +template<typename From, typename To> +To myMap(const From &f) +{ + return To(f.value * 2, true); +} + +template<typename T> +void myInplaceMap(T &el) +{ + el.multiplyByTwo(); +} + +template<typename From, typename To> +class MyMap +{ +public: + To operator()(const From &el) { return To(el.value * 2, true); } +}; + +template<typename T> +class MyInplaceMap +{ +public: + void operator()(T &el) { el.multiplyByTwo(); } +}; + +template<typename From, typename To> +class MyMoveOnlyMap +{ + bool movedFrom = false; + +public: + MyMoveOnlyMap() = default; + MyMoveOnlyMap(const MyMoveOnlyMap<From, To> &) = delete; + MyMoveOnlyMap &operator=(const MyMoveOnlyMap<From, To> &) = delete; + + MyMoveOnlyMap(MyMoveOnlyMap<From, To> &&other) { other.movedFrom = true; } + MyMoveOnlyMap &operator=(MyMoveOnlyMap<From, To> &&other) { other.movedFrom = true; } + + To operator()(const From &el) + { + if (!movedFrom) + return To(el.value * 2, true); + else + return To(-1, true); + } +}; + +template<typename T> +class MyMoveOnlyInplaceMap +{ + bool movedFrom = false; + +public: + MyMoveOnlyInplaceMap() = default; + MyMoveOnlyInplaceMap(const MyMoveOnlyInplaceMap<T> &) = delete; + MyMoveOnlyInplaceMap &operator=(const MyMoveOnlyInplaceMap<T> &) = delete; + + MyMoveOnlyInplaceMap(MyMoveOnlyInplaceMap<T> &&other) { other.movedFrom = true; } + MyMoveOnlyInplaceMap &operator=(MyMoveOnlyInplaceMap<T> &&other) { other.movedFrom = true; } + + void operator()(T &el) + { + if (!movedFrom) + el.multiplyByTwo(); + } +}; + +template<typename From, typename To> +void myReduce(To &sum, const From &val) +{ + sum.value += val.value; +} + +template<typename From, typename To> +class MyReduce +{ +public: + void operator()(To &sum, const From &val) { sum.value += val.value; } +}; + +template<typename From, typename To> +class MyMoveOnlyReduce +{ + bool movedFrom = false; + +public: + MyMoveOnlyReduce() = default; + MyMoveOnlyReduce(const MyMoveOnlyReduce<From, To> &) = delete; + MyMoveOnlyReduce &operator=(const MyMoveOnlyReduce<From, To> &) = delete; + + MyMoveOnlyReduce(MyMoveOnlyReduce<From, To> &&other) { other.movedFrom = true; } + MyMoveOnlyReduce &operator=(MyMoveOnlyReduce<From, To> &&other) { other.movedFrom = true; } + + void operator()(To &sum, const From &val) + { + if (!movedFrom) + sum.value += val.value; + } +}; + +QT_BEGIN_NAMESPACE + +// pretty printing +template<typename tag> +char *toString(const SequenceItem<tag> &i) +{ + using QTest::toString; + return toString(QString::number(i.value)); +} + +// pretty printing +template<typename T> +char *toString(const std::vector<T> &vec) +{ + using QTest::toString; + QString result(""); + for (const auto &i : vec) { + result.append(QString::number(i.value) + ", "); + } + if (result.size()) + result.chop(2); + return toString(result); +} + +QT_END_NAMESPACE + +#endif // QTBASE_GENERATION_HELPERS_H |