std::forward<UnaryPredicate>(P));
}
+/// Provide wrappers to std::any_of which take ranges instead of having to pass
+/// begin/end explicitly.
+template <typename R, class UnaryPredicate>
+bool any_of(R &&Range, UnaryPredicate &&P) {
+ return std::any_of(Range.begin(), Range.end(),
+ std::forward<UnaryPredicate>(P));
+}
+
//===----------------------------------------------------------------------===//
// Extra additions to <memory>
//===----------------------------------------------------------------------===//
// The only time we can solve this is when we have all constant indices.
// Otherwise, we cannot determine the overflow conditions.
- if (std::any_of(op_begin(), op_end(),
- [](const SCEV *Op) { return !isa<SCEVConstant>(Op);}))
+ if (any_of(operands(), [](const SCEV *Op) { return !isa<SCEVConstant>(Op); }))
return SE.getCouldNotCompute();
// Okay at this point we know that all elements of the chrec are constants and
return false;
auto &SCEVPreds = ScevPredsIt->second;
- return std::any_of(SCEVPreds.begin(), SCEVPreds.end(),
- [N](const SCEVPredicate *I) { return I->implies(N); });
+ return any_of(SCEVPreds,
+ [N](const SCEVPredicate *I) { return I->implies(N); });
}
const SCEV *SCEVUnionPredicate::getExpr() const { return nullptr; }
#include "llvm-pdbdump.h"
+#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Regex.h"
#include <algorithm>
namespace {
-template <class T, class Pred> bool any_of_range(T &&R, Pred P) {
- return std::any_of(R.begin(), R.end(), P);
-}
-
bool IsItemExcluded(llvm::StringRef Item,
std::list<llvm::Regex> &IncludeFilters,
std::list<llvm::Regex> &ExcludeFilters) {
// Include takes priority over exclude. If the user specified include
// filters, and none of them include this item, them item is gone.
- if (!IncludeFilters.empty() && !any_of_range(IncludeFilters, match_pred))
+ if (!IncludeFilters.empty() && !any_of(IncludeFilters, match_pred))
return true;
- if (any_of_range(ExcludeFilters, match_pred))
+ if (any_of(ExcludeFilters, match_pred))
return true;
return false;