Utils: Add predicates for comparison to constant values

Many STL algorithms have value version. So you can only use a predicate:

std::stable_partition(std::begin(list), std::end(list), [](int entry) {
     return entry < 20;
});

With this predicates you can write it in a shorter form:

std::stable_partition(std::begin(list), std::end(list), lessThan(20));

The find helpers are moved to predicates too.

Change-Id: I791b3105ca84ef7c5a519d22589a91b5548cf3e4
Reviewed-by: Orgad Shaneh <orgads@gmail.com>
Reviewed-by: Eike Ziller <eike.ziller@qt.io>

src/libs/utils/algorithm.h

@@ -25,10 +25,11 @@
 
 #pragma once
 
+#include "predicates.h"
+
 #include <qcompilerdetection.h> // for Q_REQUIRED_RESULT
 
 #include <algorithm>
-#include <functional>
 #include <tuple>
 
 #include <QStringList>
@@ -136,23 +137,6 @@ typename T::value_type findOrDefault(const T &container, R (S::*function)() cons
     return findOr(container, typename T::value_type(), function);
 }
 
-//////////////////
-// find helpers
-//////////////////
-template<typename R, typename S, typename T>
-decltype(auto) equal(R (S::*function)() const, T value)
-{
-    // This should use std::equal_to<> instead of std::eqaul_to<T>,
-    // but that's not supported everywhere yet, since it is C++14
-    return std::bind<bool>(std::equal_to<T>(), value, std::bind(function, std::placeholders::_1));
-}
-
-template<typename R, typename S, typename T>
-decltype(auto) equal(R S::*member, T value)
-{
-    return std::bind<bool>(std::equal_to<T>(), value, std::bind(member, std::placeholders::_1));
-}
-
 //////////////////
 // max element
 //////////////////

src/libs/utils/predicates.h

@@ -0,0 +1,132 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** 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
+** 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.
+**
+** 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.
+**
+****************************************************************************/
+
+#pragma once
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+namespace Utils
+{
+
+//////////////////
+// find helpers
+//////////////////
+template<typename R, typename S, typename T>
+decltype(auto) equal(R (S::*function)() const, T value)
+{
+    // This should use std::equal_to<> instead of std::equal_to<T>,
+    // but that's not supported everywhere yet, since it is C++14
+    return std::bind<bool>(std::equal_to<T>(), value, std::bind(function, std::placeholders::_1));
+}
+
+template<typename R, typename S, typename T>
+decltype(auto) equal(R S::*member, T value)
+{
+    return std::bind<bool>(std::equal_to<T>(), value, std::bind(member, std::placeholders::_1));
+}
+
+//////////////////
+// comparison predicates
+//////////////////
+template <typename Type>
+auto equalTo(Type &&value)
+{
+    return [value = std::forward<Type>(value)] (const auto &entry)
+    {
+        static_assert(std::is_same<std::decay_t<Type>,
+                      std::decay_t<decltype(entry)>>::value,
+                      "The container and predicate type of equalTo should be the same to prevent "
+                      "unnecessary conversion.");
+        return entry == value;
+    };
+}
+
+template <typename Type>
+auto unequalTo(Type &&value)
+{
+    return [value = std::forward<Type>(value)] (const auto &entry)
+    {
+        static_assert(std::is_same<std::decay_t<Type>,
+                      std::decay_t<decltype(entry)>>::value,
+                      "The container and predicate type of unequalTo should be the same to prevent "
+                      "unnecessary conversion.");
+        return !(entry == value);
+    };
+}
+
+template <typename Type>
+auto lessThan(Type &&value)
+{
+    return [value = std::forward<Type>(value)] (const auto &entry)
+    {
+        static_assert(std::is_same<std::decay_t<Type>,
+                      std::decay_t<decltype(entry)>>::value,
+                      "The container and predicate type of unequalTo should be the same to prevent "
+                      "unnecessary conversion.");
+        return entry < value;
+    };
+}
+
+template <typename Type>
+auto lessEqualThan(Type &&value)
+{
+    return [value = std::forward<Type>(value)] (const auto &entry)
+    {
+        static_assert(std::is_same<std::decay_t<Type>,
+                      std::decay_t<decltype(entry)>>::value,
+                      "The container and predicate type of lessEqualThan should be the same to "
+                      "prevent unnecessary conversion.");
+        return !(value < entry);
+    };
+}
+
+template <typename Type>
+auto greaterThan(Type &&value)
+{
+    return [value = std::forward<Type>(value)] (const auto &entry)
+    {
+        static_assert(std::is_same<std::decay_t<Type>,
+                      std::decay_t<decltype(entry)>>::value,
+                      "The container and predicate type of greaterThan should be the same to "
+                      "prevent unnecessary conversion.");
+        return value < entry;
+    };
+}
+
+template <typename Type>
+auto greaterEqualThan(Type &&value)
+{
+    return [value = std::forward<Type>(value)] (const auto &entry)
+    {
+        static_assert(std::is_same<std::decay_t<Type>,
+                      std::decay_t<decltype(entry)>>::value,
+                      "The container and predicate type of greaterEqualThan should be the same to "
+                      "prevent unnecessary conversion.");
+        return !(entry < value);
+    };
+}
+} // namespace Utils

src/libs/utils/utils-lib.pri

@@ -249,6 +249,7 @@ HEADERS += \
     $$PWD/highlightingitemdelegate.h \
     $$PWD/camelhumpmatcher.h \
     $$PWD/textutils.h \
+    $$PWD/predicates.h \
     $$PWD/url.h
 
 FORMS += $$PWD/filewizardpage.ui \

src/libs/utils/utils.qbs

@@ -163,6 +163,7 @@ Project {
             "pathlisteditor.h",
             "persistentsettings.cpp",
             "persistentsettings.h",
+            "predicates.h"
             "port.cpp",
             "port.h",
             "portlist.cpp",