ab3552a189
-- f13697e3d33803f9667d124072da4f6dd8bfbf85 by Andy Soffer <asoffer@google.com>: Addressing https://github.com/abseil/abseil-cpp/issues/314, fixing CMakeLists.txt to reference ABSL_TEST_COPTS rather than ABSL_DEFAULT_COPTS. ABSL_TEST_COPTS should be preferred for all tests so that they are configured consistently (moreover, CMake should agree with Bazel). PiperOrigin-RevId: 274932312 -- c31c24a1fa6bb98136adf51ef37c0818ac366690 by Derek Mauro <dmauro@google.com>: Silence MSAN in the stack consumption test utility PiperOrigin-RevId: 274912950 -- 2412913c05a246cd527cd4c31452f126e9129f3a by CJ Johnson <johnsoncj@google.com>: Internal change PiperOrigin-RevId: 274847103 -- 75e984a93b5760873501b96ac3229ccfd955daf8 by Abseil Team <absl-team@google.com>: Reformat BUILD file to current standards. PiperOrigin-RevId: 274815392 -- a2780e085f1df1e4ca2c814a58c893d1b78a1d9c by Samuel Benzaquen <sbenza@google.com>: Fix invalid result regarding leading zeros in the exponent. PiperOrigin-RevId: 274808017 -- dd402e1cb5c4ebacb576372ae24bf289d729d323 by Samuel Benzaquen <sbenza@google.com>: Make string_view's relational operators constexpr when possible. PiperOrigin-RevId: 274807873 -- b4ef32565653a5da1cb8bb8d0351586d23519658 by Abseil Team <absl-team@google.com>: Internal rework. PiperOrigin-RevId: 274787159 -- 70d81971c5914e6785b8e8a9d4f6eb2655dd62c0 by Gennadiy Rozental <rogeeff@google.com>: Internal rework. PiperOrigin-RevId: 274715557 -- 14f5b0440e353b899cafaaa15b53e77f98f401af by Gennadiy Rozental <rogeeff@google.com>: Make deprecated statements about ParseFLag/UnparseFlag consistent in a file. PiperOrigin-RevId: 274668123 -- 2e85adbdbb92612e4d750bc34fbca3333128b42d by Abseil Team <absl-team@google.com>: Allow absl::c_equal to be used with arrays. This is achieved by allowing container size computation for arrays. PiperOrigin-RevId: 274426830 -- 219719f107226d328773e6cec99fb473f5d3119c by Gennadiy Rozental <rogeeff@google.com>: Release correct extension interfaces to support usage of absl::Time and absl::Duration as ABSL_FLAG PiperOrigin-RevId: 274273788 -- 47a77f93fda23b69b4a6bdbd506fe643c69a5579 by Gennadiy Rozental <rogeeff@google.com>: Rework of flags persistence/FlagSaver internals. PiperOrigin-RevId: 274225213 -- 7807be3fe757c19e3b0c487298387683d4c9f5b3 by Abseil Team <absl-team@google.com>: Switch reference to sdkddkver.h to lowercase, matching conventions used in the Windows SDK and other uses. This helps to avoid confusion on case-sensitive filesystems. PiperOrigin-RevId: 274061877 -- 561304090087a19f1d10f0475f564fe132ebf06e by Andy Getzendanner <durandal@google.com>: Fix ABSL_WAITER_MODE detection for mingw Import of https://github.com/abseil/abseil-cpp/pull/342 PiperOrigin-RevId: 274030071 -- 9b3caac2cf202b9d440dfa1b4ffd538ac4bf715b by Derek Mauro <dmauro@google.com>: Support using Abseil with the musl libc implementation. Only test changes were required: * Workaround for a bug in sigaltstack() on musl * printf-style pointer formatting (%p) is implementation defined, so verify StrFromat produces something compatible * Fix detection of feenableexcept() PiperOrigin-RevId: 274011666 -- 73e8a938fc139e1cc8670d4513a445bacc855539 by Abseil Team <absl-team@google.com>: nvcc workaround: explicitly specify the definition of node_handle::Base PiperOrigin-RevId: 274011392 -- ab9cc6d042aca7d48e16c504ab10eab39433f4b2 by Andy Soffer <asoffer@google.com>: Internal change PiperOrigin-RevId: 273996318 -- e567c4979ca99c7e71821ec1523b8f5edd2c76ac by Abseil Team <absl-team@google.com>: Introduce a type alias to work around an nvcc bug. On the previous code, nvcc gets confused thinking that T has to be a parameter pack, as IsDecomposable accepts one. PiperOrigin-RevId: 273980472 -- 105b6e6339b77a32f4432de05f44cd3f9c436751 by Eric Fiselier <ericwf@google.com>: Import of CCTZ from GitHub. PiperOrigin-RevId: 273955589 -- 8feb87ff1d7e721fe094855e67c19539d5e582b7 by Abseil Team <absl-team@google.com>: Avoid dual-exporting scheduling_mode.h PiperOrigin-RevId: 273825112 -- fbc37854776d295dae98fb9d06a541f296daab95 by Andy Getzendanner <durandal@google.com>: Fix ABSL_HAVE_ALARM check on mingw Import of https://github.com/abseil/abseil-cpp/pull/341 PiperOrigin-RevId: 273817839 -- 6aedcd63a735b9133e143b043744ba0a25407f6f by Andy Soffer <asoffer@google.com>: Remove bit_gen_view.h now that all callers have been migrated to bit_gen_ref.h Tested: TGP - https://test.corp.google.com/ui#id=OCL:273762409:BASE:273743370:1570639020744:3001bcb5 PiperOrigin-RevId: 273810331 -- 6573de24a66ba715c579f7f32b5c48a1d743c7f8 by Abseil Team <absl-team@google.com>: Internal change. PiperOrigin-RevId: 273589963 -- 91c8c28b6dca26d98b39e8e06a8ed17c701ff793 by Abseil Team <absl-team@google.com>: Update macro name for `ABSL_GUARDED_BY()` in the example section. PiperOrigin-RevId: 273286983 -- 0ff7d1a93d70f8ecd693f8dbb98b7a4a016ca2a4 by Abseil Team <absl-team@google.com>: Fix potential integer overflow in the absl time library. In absl::FromTM, the tm.tm_year is added by 1900 regarding that tm.tm_year represents the years since 1900. This change checks integer overflow before doing the arithmetic operation. PiperOrigin-RevId: 273092952 -- b41c2a1310086807be09a833099ae6d4009f037c by Gennadiy Rozental <rogeeff@google.com>: Correctly Unlock the global mutex in case of concurrent flag initialization. Fixes #386 PiperOrigin-RevId: 272979749 -- c53103e71b2a6063af3c6d4ff68aa2d8f9ae9e06 by Abseil Team <absl-team@google.com>: Try to become idle only when there is no wakeup. Immediately after waking up (when futex wait returns), the current thread tries to become idle doing bunch of memory loads and a branch. Problem is that there is a good chance that we woke up due to a wakeup, especially for actively used threads. For such wakeups, calling MaybeBecomeIdle() would be a waste of cycles. Instead, call MaybeBecomeIdle() only when we are sure there is no wakeup. For idle threads the net effect should be the same. For active, threads this will be more efficient. Moreover, since MaybeBecomeIdle() is called before waiting on the futex, the current thread will try to become idle before sleeping. This should result in more accurate idleness and more efficient release of thread resources. PiperOrigin-RevId: 272940381 GitOrigin-RevId: f13697e3d33803f9667d124072da4f6dd8bfbf85 Change-Id: I36de05aec12595183725652dd362dfa58fb095d0
1724 lines
74 KiB
C++
1724 lines
74 KiB
C++
// Copyright 2017 The Abseil Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
// File: container.h
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// This header file provides Container-based versions of algorithmic functions
|
|
// within the C++ standard library. The following standard library sets of
|
|
// functions are covered within this file:
|
|
//
|
|
// * Algorithmic <iterator> functions
|
|
// * Algorithmic <numeric> functions
|
|
// * <algorithm> functions
|
|
//
|
|
// The standard library functions operate on iterator ranges; the functions
|
|
// within this API operate on containers, though many return iterator ranges.
|
|
//
|
|
// All functions within this API are named with a `c_` prefix. Calls such as
|
|
// `absl::c_xx(container, ...) are equivalent to std:: functions such as
|
|
// `std::xx(std::begin(cont), std::end(cont), ...)`. Functions that act on
|
|
// iterators but not conceptually on iterator ranges (e.g. `std::iter_swap`)
|
|
// have no equivalent here.
|
|
//
|
|
// For template parameter and variable naming, `C` indicates the container type
|
|
// to which the function is applied, `Pred` indicates the predicate object type
|
|
// to be used by the function and `T` indicates the applicable element type.
|
|
|
|
#ifndef ABSL_ALGORITHM_CONTAINER_H_
|
|
#define ABSL_ALGORITHM_CONTAINER_H_
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <iterator>
|
|
#include <numeric>
|
|
#include <type_traits>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "absl/algorithm/algorithm.h"
|
|
#include "absl/base/macros.h"
|
|
#include "absl/meta/type_traits.h"
|
|
|
|
namespace absl {
|
|
namespace container_algorithm_internal {
|
|
|
|
// NOTE: it is important to defer to ADL lookup for building with C++ modules,
|
|
// especially for headers like <valarray> which are not visible from this file
|
|
// but specialize std::begin and std::end.
|
|
using std::begin;
|
|
using std::end;
|
|
|
|
// The type of the iterator given by begin(c) (possibly std::begin(c)).
|
|
// ContainerIter<const vector<T>> gives vector<T>::const_iterator,
|
|
// while ContainerIter<vector<T>> gives vector<T>::iterator.
|
|
template <typename C>
|
|
using ContainerIter = decltype(begin(std::declval<C&>()));
|
|
|
|
// An MSVC bug involving template parameter substitution requires us to use
|
|
// decltype() here instead of just std::pair.
|
|
template <typename C1, typename C2>
|
|
using ContainerIterPairType =
|
|
decltype(std::make_pair(ContainerIter<C1>(), ContainerIter<C2>()));
|
|
|
|
template <typename C>
|
|
using ContainerDifferenceType =
|
|
decltype(std::distance(std::declval<ContainerIter<C>>(),
|
|
std::declval<ContainerIter<C>>()));
|
|
|
|
template <typename C>
|
|
using ContainerPointerType =
|
|
typename std::iterator_traits<ContainerIter<C>>::pointer;
|
|
|
|
// container_algorithm_internal::c_begin and
|
|
// container_algorithm_internal::c_end are abbreviations for proper ADL
|
|
// lookup of std::begin and std::end, i.e.
|
|
// using std::begin;
|
|
// using std::end;
|
|
// std::foo(begin(c), end(c);
|
|
// becomes
|
|
// std::foo(container_algorithm_internal::begin(c),
|
|
// container_algorithm_internal::end(c));
|
|
// These are meant for internal use only.
|
|
|
|
template <typename C>
|
|
ContainerIter<C> c_begin(C& c) { return begin(c); }
|
|
|
|
template <typename C>
|
|
ContainerIter<C> c_end(C& c) { return end(c); }
|
|
|
|
template <typename T>
|
|
struct IsUnorderedContainer : std::false_type {};
|
|
|
|
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
|
|
struct IsUnorderedContainer<
|
|
std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
|
|
|
|
template <class Key, class Hash, class KeyEqual, class Allocator>
|
|
struct IsUnorderedContainer<std::unordered_set<Key, Hash, KeyEqual, Allocator>>
|
|
: std::true_type {};
|
|
|
|
// container_algorithm_internal::c_size. It is meant for internal use only.
|
|
|
|
template <class C>
|
|
auto c_size(C& c) -> decltype(c.size()) {
|
|
return c.size();
|
|
}
|
|
|
|
template <class T, std::size_t N>
|
|
constexpr std::size_t c_size(T (&)[N]) {
|
|
return N;
|
|
}
|
|
|
|
} // namespace container_algorithm_internal
|
|
|
|
// PUBLIC API
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Abseil algorithm.h functions
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_linear_search()
|
|
//
|
|
// Container-based version of absl::linear_search() for performing a linear
|
|
// search within a container.
|
|
template <typename C, typename EqualityComparable>
|
|
bool c_linear_search(const C& c, EqualityComparable&& value) {
|
|
return linear_search(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<EqualityComparable>(value));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <iterator> algorithms
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_distance()
|
|
//
|
|
// Container-based version of the <iterator> `std::distance()` function to
|
|
// return the number of elements within a container.
|
|
template <typename C>
|
|
container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
|
|
const C& c) {
|
|
return std::distance(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Non-modifying sequence operations
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_all_of()
|
|
//
|
|
// Container-based version of the <algorithm> `std::all_of()` function to
|
|
// test a condition on all elements within a container.
|
|
template <typename C, typename Pred>
|
|
bool c_all_of(const C& c, Pred&& pred) {
|
|
return std::all_of(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_any_of()
|
|
//
|
|
// Container-based version of the <algorithm> `std::any_of()` function to
|
|
// test if any element in a container fulfills a condition.
|
|
template <typename C, typename Pred>
|
|
bool c_any_of(const C& c, Pred&& pred) {
|
|
return std::any_of(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_none_of()
|
|
//
|
|
// Container-based version of the <algorithm> `std::none_of()` function to
|
|
// test if no elements in a container fulfil a condition.
|
|
template <typename C, typename Pred>
|
|
bool c_none_of(const C& c, Pred&& pred) {
|
|
return std::none_of(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_for_each()
|
|
//
|
|
// Container-based version of the <algorithm> `std::for_each()` function to
|
|
// apply a function to a container's elements.
|
|
template <typename C, typename Function>
|
|
decay_t<Function> c_for_each(C&& c, Function&& f) {
|
|
return std::for_each(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Function>(f));
|
|
}
|
|
|
|
// c_find()
|
|
//
|
|
// Container-based version of the <algorithm> `std::find()` function to find
|
|
// the first element containing the passed value within a container value.
|
|
template <typename C, typename T>
|
|
container_algorithm_internal::ContainerIter<C> c_find(C& c, T&& value) {
|
|
return std::find(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// c_find_if()
|
|
//
|
|
// Container-based version of the <algorithm> `std::find_if()` function to find
|
|
// the first element in a container matching the given condition.
|
|
template <typename C, typename Pred>
|
|
container_algorithm_internal::ContainerIter<C> c_find_if(C& c, Pred&& pred) {
|
|
return std::find_if(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_find_if_not()
|
|
//
|
|
// Container-based version of the <algorithm> `std::find_if_not()` function to
|
|
// find the first element in a container not matching the given condition.
|
|
template <typename C, typename Pred>
|
|
container_algorithm_internal::ContainerIter<C> c_find_if_not(C& c,
|
|
Pred&& pred) {
|
|
return std::find_if_not(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_find_end()
|
|
//
|
|
// Container-based version of the <algorithm> `std::find_end()` function to
|
|
// find the last subsequence within a container.
|
|
template <typename Sequence1, typename Sequence2>
|
|
container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
|
|
Sequence1& sequence, Sequence2& subsequence) {
|
|
return std::find_end(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
container_algorithm_internal::c_begin(subsequence),
|
|
container_algorithm_internal::c_end(subsequence));
|
|
}
|
|
|
|
// Overload of c_find_end() for using a predicate evaluation other than `==` as
|
|
// the function's test condition.
|
|
template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
|
|
container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
|
|
Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
|
|
return std::find_end(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
container_algorithm_internal::c_begin(subsequence),
|
|
container_algorithm_internal::c_end(subsequence),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_find_first_of()
|
|
//
|
|
// Container-based version of the <algorithm> `std::find_first_of()` function to
|
|
// find the first elements in an ordered set within a container.
|
|
template <typename C1, typename C2>
|
|
container_algorithm_internal::ContainerIter<C1> c_find_first_of(C1& container,
|
|
C2& options) {
|
|
return std::find_first_of(container_algorithm_internal::c_begin(container),
|
|
container_algorithm_internal::c_end(container),
|
|
container_algorithm_internal::c_begin(options),
|
|
container_algorithm_internal::c_end(options));
|
|
}
|
|
|
|
// Overload of c_find_first_of() for using a predicate evaluation other than
|
|
// `==` as the function's test condition.
|
|
template <typename C1, typename C2, typename BinaryPredicate>
|
|
container_algorithm_internal::ContainerIter<C1> c_find_first_of(
|
|
C1& container, C2& options, BinaryPredicate&& pred) {
|
|
return std::find_first_of(container_algorithm_internal::c_begin(container),
|
|
container_algorithm_internal::c_end(container),
|
|
container_algorithm_internal::c_begin(options),
|
|
container_algorithm_internal::c_end(options),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_adjacent_find()
|
|
//
|
|
// Container-based version of the <algorithm> `std::adjacent_find()` function to
|
|
// find equal adjacent elements within a container.
|
|
template <typename Sequence>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
|
|
Sequence& sequence) {
|
|
return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_adjacent_find() for using a predicate evaluation other than
|
|
// `==` as the function's test condition.
|
|
template <typename Sequence, typename BinaryPredicate>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
|
|
Sequence& sequence, BinaryPredicate&& pred) {
|
|
return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_count()
|
|
//
|
|
// Container-based version of the <algorithm> `std::count()` function to count
|
|
// values that match within a container.
|
|
template <typename C, typename T>
|
|
container_algorithm_internal::ContainerDifferenceType<const C> c_count(
|
|
const C& c, T&& value) {
|
|
return std::count(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// c_count_if()
|
|
//
|
|
// Container-based version of the <algorithm> `std::count_if()` function to
|
|
// count values matching a condition within a container.
|
|
template <typename C, typename Pred>
|
|
container_algorithm_internal::ContainerDifferenceType<const C> c_count_if(
|
|
const C& c, Pred&& pred) {
|
|
return std::count_if(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_mismatch()
|
|
//
|
|
// Container-based version of the <algorithm> `std::mismatch()` function to
|
|
// return the first element where two ordered containers differ.
|
|
template <typename C1, typename C2>
|
|
container_algorithm_internal::ContainerIterPairType<C1, C2>
|
|
c_mismatch(C1& c1, C2& c2) {
|
|
return std::mismatch(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2));
|
|
}
|
|
|
|
// Overload of c_mismatch() for using a predicate evaluation other than `==` as
|
|
// the function's test condition.
|
|
template <typename C1, typename C2, typename BinaryPredicate>
|
|
container_algorithm_internal::ContainerIterPairType<C1, C2>
|
|
c_mismatch(C1& c1, C2& c2, BinaryPredicate&& pred) {
|
|
return std::mismatch(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_equal()
|
|
//
|
|
// Container-based version of the <algorithm> `std::equal()` function to
|
|
// test whether two containers are equal.
|
|
//
|
|
// NOTE: the semantics of c_equal() are slightly different than those of
|
|
// equal(): while the latter iterates over the second container only up to the
|
|
// size of the first container, c_equal() also checks whether the container
|
|
// sizes are equal. This better matches expectations about c_equal() based on
|
|
// its signature.
|
|
//
|
|
// Example:
|
|
// vector v1 = <1, 2, 3>;
|
|
// vector v2 = <1, 2, 3, 4>;
|
|
// equal(std::begin(v1), std::end(v1), std::begin(v2)) returns true
|
|
// c_equal(v1, v2) returns false
|
|
|
|
template <typename C1, typename C2>
|
|
bool c_equal(const C1& c1, const C2& c2) {
|
|
return ((container_algorithm_internal::c_size(c1) ==
|
|
container_algorithm_internal::c_size(c2)) &&
|
|
std::equal(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2)));
|
|
}
|
|
|
|
// Overload of c_equal() for using a predicate evaluation other than `==` as
|
|
// the function's test condition.
|
|
template <typename C1, typename C2, typename BinaryPredicate>
|
|
bool c_equal(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
|
|
return ((container_algorithm_internal::c_size(c1) ==
|
|
container_algorithm_internal::c_size(c2)) &&
|
|
std::equal(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
std::forward<BinaryPredicate>(pred)));
|
|
}
|
|
|
|
// c_is_permutation()
|
|
//
|
|
// Container-based version of the <algorithm> `std::is_permutation()` function
|
|
// to test whether a container is a permutation of another.
|
|
template <typename C1, typename C2>
|
|
bool c_is_permutation(const C1& c1, const C2& c2) {
|
|
using std::begin;
|
|
using std::end;
|
|
return c1.size() == c2.size() &&
|
|
std::is_permutation(begin(c1), end(c1), begin(c2));
|
|
}
|
|
|
|
// Overload of c_is_permutation() for using a predicate evaluation other than
|
|
// `==` as the function's test condition.
|
|
template <typename C1, typename C2, typename BinaryPredicate>
|
|
bool c_is_permutation(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
|
|
using std::begin;
|
|
using std::end;
|
|
return c1.size() == c2.size() &&
|
|
std::is_permutation(begin(c1), end(c1), begin(c2),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_search()
|
|
//
|
|
// Container-based version of the <algorithm> `std::search()` function to search
|
|
// a container for a subsequence.
|
|
template <typename Sequence1, typename Sequence2>
|
|
container_algorithm_internal::ContainerIter<Sequence1> c_search(
|
|
Sequence1& sequence, Sequence2& subsequence) {
|
|
return std::search(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
container_algorithm_internal::c_begin(subsequence),
|
|
container_algorithm_internal::c_end(subsequence));
|
|
}
|
|
|
|
// Overload of c_search() for using a predicate evaluation other than
|
|
// `==` as the function's test condition.
|
|
template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
|
|
container_algorithm_internal::ContainerIter<Sequence1> c_search(
|
|
Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
|
|
return std::search(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
container_algorithm_internal::c_begin(subsequence),
|
|
container_algorithm_internal::c_end(subsequence),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_search_n()
|
|
//
|
|
// Container-based version of the <algorithm> `std::search_n()` function to
|
|
// search a container for the first sequence of N elements.
|
|
template <typename Sequence, typename Size, typename T>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_search_n(
|
|
Sequence& sequence, Size count, T&& value) {
|
|
return std::search_n(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence), count,
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// Overload of c_search_n() for using a predicate evaluation other than
|
|
// `==` as the function's test condition.
|
|
template <typename Sequence, typename Size, typename T,
|
|
typename BinaryPredicate>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_search_n(
|
|
Sequence& sequence, Size count, T&& value, BinaryPredicate&& pred) {
|
|
return std::search_n(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence), count,
|
|
std::forward<T>(value),
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Modifying sequence operations
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::copy()` function to copy a
|
|
// container's elements into an iterator.
|
|
template <typename InputSequence, typename OutputIterator>
|
|
OutputIterator c_copy(const InputSequence& input, OutputIterator output) {
|
|
return std::copy(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input), output);
|
|
}
|
|
|
|
// c_copy_n()
|
|
//
|
|
// Container-based version of the <algorithm> `std::copy_n()` function to copy a
|
|
// container's first N elements into an iterator.
|
|
template <typename C, typename Size, typename OutputIterator>
|
|
OutputIterator c_copy_n(const C& input, Size n, OutputIterator output) {
|
|
return std::copy_n(container_algorithm_internal::c_begin(input), n, output);
|
|
}
|
|
|
|
// c_copy_if()
|
|
//
|
|
// Container-based version of the <algorithm> `std::copy_if()` function to copy
|
|
// a container's elements satisfying some condition into an iterator.
|
|
template <typename InputSequence, typename OutputIterator, typename Pred>
|
|
OutputIterator c_copy_if(const InputSequence& input, OutputIterator output,
|
|
Pred&& pred) {
|
|
return std::copy_if(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input), output,
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_copy_backward()
|
|
//
|
|
// Container-based version of the <algorithm> `std::copy_backward()` function to
|
|
// copy a container's elements in reverse order into an iterator.
|
|
template <typename C, typename BidirectionalIterator>
|
|
BidirectionalIterator c_copy_backward(const C& src,
|
|
BidirectionalIterator dest) {
|
|
return std::copy_backward(container_algorithm_internal::c_begin(src),
|
|
container_algorithm_internal::c_end(src), dest);
|
|
}
|
|
|
|
// c_move()
|
|
//
|
|
// Container-based version of the <algorithm> `std::move()` function to move
|
|
// a container's elements into an iterator.
|
|
template <typename C, typename OutputIterator>
|
|
OutputIterator c_move(C&& src, OutputIterator dest) {
|
|
return std::move(container_algorithm_internal::c_begin(src),
|
|
container_algorithm_internal::c_end(src), dest);
|
|
}
|
|
|
|
// c_move_backward()
|
|
//
|
|
// Container-based version of the <algorithm> `std::move_backward()` function to
|
|
// move a container's elements into an iterator in reverse order.
|
|
template <typename C, typename BidirectionalIterator>
|
|
BidirectionalIterator c_move_backward(C&& src, BidirectionalIterator dest) {
|
|
return std::move_backward(container_algorithm_internal::c_begin(src),
|
|
container_algorithm_internal::c_end(src), dest);
|
|
}
|
|
|
|
// c_swap_ranges()
|
|
//
|
|
// Container-based version of the <algorithm> `std::swap_ranges()` function to
|
|
// swap a container's elements with another container's elements.
|
|
template <typename C1, typename C2>
|
|
container_algorithm_internal::ContainerIter<C2> c_swap_ranges(C1& c1, C2& c2) {
|
|
return std::swap_ranges(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2));
|
|
}
|
|
|
|
// c_transform()
|
|
//
|
|
// Container-based version of the <algorithm> `std::transform()` function to
|
|
// transform a container's elements using the unary operation, storing the
|
|
// result in an iterator pointing to the last transformed element in the output
|
|
// range.
|
|
template <typename InputSequence, typename OutputIterator, typename UnaryOp>
|
|
OutputIterator c_transform(const InputSequence& input, OutputIterator output,
|
|
UnaryOp&& unary_op) {
|
|
return std::transform(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input), output,
|
|
std::forward<UnaryOp>(unary_op));
|
|
}
|
|
|
|
// Overload of c_transform() for performing a transformation using a binary
|
|
// predicate.
|
|
template <typename InputSequence1, typename InputSequence2,
|
|
typename OutputIterator, typename BinaryOp>
|
|
OutputIterator c_transform(const InputSequence1& input1,
|
|
const InputSequence2& input2, OutputIterator output,
|
|
BinaryOp&& binary_op) {
|
|
return std::transform(container_algorithm_internal::c_begin(input1),
|
|
container_algorithm_internal::c_end(input1),
|
|
container_algorithm_internal::c_begin(input2), output,
|
|
std::forward<BinaryOp>(binary_op));
|
|
}
|
|
|
|
// c_replace()
|
|
//
|
|
// Container-based version of the <algorithm> `std::replace()` function to
|
|
// replace a container's elements of some value with a new value. The container
|
|
// is modified in place.
|
|
template <typename Sequence, typename T>
|
|
void c_replace(Sequence& sequence, const T& old_value, const T& new_value) {
|
|
std::replace(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence), old_value,
|
|
new_value);
|
|
}
|
|
|
|
// c_replace_if()
|
|
//
|
|
// Container-based version of the <algorithm> `std::replace_if()` function to
|
|
// replace a container's elements of some value with a new value based on some
|
|
// condition. The container is modified in place.
|
|
template <typename C, typename Pred, typename T>
|
|
void c_replace_if(C& c, Pred&& pred, T&& new_value) {
|
|
std::replace_if(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred), std::forward<T>(new_value));
|
|
}
|
|
|
|
// c_replace_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::replace_copy()` function to
|
|
// replace a container's elements of some value with a new value and return the
|
|
// results within an iterator.
|
|
template <typename C, typename OutputIterator, typename T>
|
|
OutputIterator c_replace_copy(const C& c, OutputIterator result, T&& old_value,
|
|
T&& new_value) {
|
|
return std::replace_copy(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), result,
|
|
std::forward<T>(old_value),
|
|
std::forward<T>(new_value));
|
|
}
|
|
|
|
// c_replace_copy_if()
|
|
//
|
|
// Container-based version of the <algorithm> `std::replace_copy_if()` function
|
|
// to replace a container's elements of some value with a new value based on
|
|
// some condition, and return the results within an iterator.
|
|
template <typename C, typename OutputIterator, typename Pred, typename T>
|
|
OutputIterator c_replace_copy_if(const C& c, OutputIterator result, Pred&& pred,
|
|
T&& new_value) {
|
|
return std::replace_copy_if(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), result,
|
|
std::forward<Pred>(pred),
|
|
std::forward<T>(new_value));
|
|
}
|
|
|
|
// c_fill()
|
|
//
|
|
// Container-based version of the <algorithm> `std::fill()` function to fill a
|
|
// container with some value.
|
|
template <typename C, typename T>
|
|
void c_fill(C& c, T&& value) {
|
|
std::fill(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), std::forward<T>(value));
|
|
}
|
|
|
|
// c_fill_n()
|
|
//
|
|
// Container-based version of the <algorithm> `std::fill_n()` function to fill
|
|
// the first N elements in a container with some value.
|
|
template <typename C, typename Size, typename T>
|
|
void c_fill_n(C& c, Size n, T&& value) {
|
|
std::fill_n(container_algorithm_internal::c_begin(c), n,
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// c_generate()
|
|
//
|
|
// Container-based version of the <algorithm> `std::generate()` function to
|
|
// assign a container's elements to the values provided by the given generator.
|
|
template <typename C, typename Generator>
|
|
void c_generate(C& c, Generator&& gen) {
|
|
std::generate(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Generator>(gen));
|
|
}
|
|
|
|
// c_generate_n()
|
|
//
|
|
// Container-based version of the <algorithm> `std::generate_n()` function to
|
|
// assign a container's first N elements to the values provided by the given
|
|
// generator.
|
|
template <typename C, typename Size, typename Generator>
|
|
container_algorithm_internal::ContainerIter<C> c_generate_n(C& c, Size n,
|
|
Generator&& gen) {
|
|
return std::generate_n(container_algorithm_internal::c_begin(c), n,
|
|
std::forward<Generator>(gen));
|
|
}
|
|
|
|
// Note: `c_xx()` <algorithm> container versions for `remove()`, `remove_if()`,
|
|
// and `unique()` are omitted, because it's not clear whether or not such
|
|
// functions should call erase on their supplied sequences afterwards. Either
|
|
// behavior would be surprising for a different set of users.
|
|
|
|
// c_remove_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::remove_copy()` function to
|
|
// copy a container's elements while removing any elements matching the given
|
|
// `value`.
|
|
template <typename C, typename OutputIterator, typename T>
|
|
OutputIterator c_remove_copy(const C& c, OutputIterator result, T&& value) {
|
|
return std::remove_copy(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), result,
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// c_remove_copy_if()
|
|
//
|
|
// Container-based version of the <algorithm> `std::remove_copy_if()` function
|
|
// to copy a container's elements while removing any elements matching the given
|
|
// condition.
|
|
template <typename C, typename OutputIterator, typename Pred>
|
|
OutputIterator c_remove_copy_if(const C& c, OutputIterator result,
|
|
Pred&& pred) {
|
|
return std::remove_copy_if(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), result,
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_unique_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::unique_copy()` function to
|
|
// copy a container's elements while removing any elements containing duplicate
|
|
// values.
|
|
template <typename C, typename OutputIterator>
|
|
OutputIterator c_unique_copy(const C& c, OutputIterator result) {
|
|
return std::unique_copy(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), result);
|
|
}
|
|
|
|
// Overload of c_unique_copy() for using a predicate evaluation other than
|
|
// `==` for comparing uniqueness of the element values.
|
|
template <typename C, typename OutputIterator, typename BinaryPredicate>
|
|
OutputIterator c_unique_copy(const C& c, OutputIterator result,
|
|
BinaryPredicate&& pred) {
|
|
return std::unique_copy(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), result,
|
|
std::forward<BinaryPredicate>(pred));
|
|
}
|
|
|
|
// c_reverse()
|
|
//
|
|
// Container-based version of the <algorithm> `std::reverse()` function to
|
|
// reverse a container's elements.
|
|
template <typename Sequence>
|
|
void c_reverse(Sequence& sequence) {
|
|
std::reverse(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// c_reverse_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::reverse()` function to
|
|
// reverse a container's elements and write them to an iterator range.
|
|
template <typename C, typename OutputIterator>
|
|
OutputIterator c_reverse_copy(const C& sequence, OutputIterator result) {
|
|
return std::reverse_copy(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
result);
|
|
}
|
|
|
|
// c_rotate()
|
|
//
|
|
// Container-based version of the <algorithm> `std::rotate()` function to
|
|
// shift a container's elements leftward such that the `middle` element becomes
|
|
// the first element in the container.
|
|
template <typename C,
|
|
typename Iterator = container_algorithm_internal::ContainerIter<C>>
|
|
Iterator c_rotate(C& sequence, Iterator middle) {
|
|
return absl::rotate(container_algorithm_internal::c_begin(sequence), middle,
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// c_rotate_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::rotate_copy()` function to
|
|
// shift a container's elements leftward such that the `middle` element becomes
|
|
// the first element in a new iterator range.
|
|
template <typename C, typename OutputIterator>
|
|
OutputIterator c_rotate_copy(
|
|
const C& sequence,
|
|
container_algorithm_internal::ContainerIter<const C> middle,
|
|
OutputIterator result) {
|
|
return std::rotate_copy(container_algorithm_internal::c_begin(sequence),
|
|
middle, container_algorithm_internal::c_end(sequence),
|
|
result);
|
|
}
|
|
|
|
// c_shuffle()
|
|
//
|
|
// Container-based version of the <algorithm> `std::shuffle()` function to
|
|
// randomly shuffle elements within the container using a `gen()` uniform random
|
|
// number generator.
|
|
template <typename RandomAccessContainer, typename UniformRandomBitGenerator>
|
|
void c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen) {
|
|
std::shuffle(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<UniformRandomBitGenerator>(gen));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Partition functions
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_is_partitioned()
|
|
//
|
|
// Container-based version of the <algorithm> `std::is_partitioned()` function
|
|
// to test whether all elements in the container for which `pred` returns `true`
|
|
// precede those for which `pred` is `false`.
|
|
template <typename C, typename Pred>
|
|
bool c_is_partitioned(const C& c, Pred&& pred) {
|
|
return std::is_partitioned(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_partition()
|
|
//
|
|
// Container-based version of the <algorithm> `std::partition()` function
|
|
// to rearrange all elements in a container in such a way that all elements for
|
|
// which `pred` returns `true` precede all those for which it returns `false`,
|
|
// returning an iterator to the first element of the second group.
|
|
template <typename C, typename Pred>
|
|
container_algorithm_internal::ContainerIter<C> c_partition(C& c, Pred&& pred) {
|
|
return std::partition(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_stable_partition()
|
|
//
|
|
// Container-based version of the <algorithm> `std::stable_partition()` function
|
|
// to rearrange all elements in a container in such a way that all elements for
|
|
// which `pred` returns `true` precede all those for which it returns `false`,
|
|
// preserving the relative ordering between the two groups. The function returns
|
|
// an iterator to the first element of the second group.
|
|
template <typename C, typename Pred>
|
|
container_algorithm_internal::ContainerIter<C> c_stable_partition(C& c,
|
|
Pred&& pred) {
|
|
return std::stable_partition(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_partition_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::partition_copy()` function
|
|
// to partition a container's elements and return them into two iterators: one
|
|
// for which `pred` returns `true`, and one for which `pred` returns `false.`
|
|
|
|
template <typename C, typename OutputIterator1, typename OutputIterator2,
|
|
typename Pred>
|
|
std::pair<OutputIterator1, OutputIterator2> c_partition_copy(
|
|
const C& c, OutputIterator1 out_true, OutputIterator2 out_false,
|
|
Pred&& pred) {
|
|
return std::partition_copy(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c), out_true,
|
|
out_false, std::forward<Pred>(pred));
|
|
}
|
|
|
|
// c_partition_point()
|
|
//
|
|
// Container-based version of the <algorithm> `std::partition_point()` function
|
|
// to return the first element of an already partitioned container for which
|
|
// the given `pred` is not `true`.
|
|
template <typename C, typename Pred>
|
|
container_algorithm_internal::ContainerIter<C> c_partition_point(C& c,
|
|
Pred&& pred) {
|
|
return std::partition_point(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Pred>(pred));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Sorting functions
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_sort()
|
|
//
|
|
// Container-based version of the <algorithm> `std::sort()` function
|
|
// to sort elements in ascending order of their values.
|
|
template <typename C>
|
|
void c_sort(C& c) {
|
|
std::sort(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_sort() for performing a `comp` comparison other than the
|
|
// default `operator<`.
|
|
template <typename C, typename Compare>
|
|
void c_sort(C& c, Compare&& comp) {
|
|
std::sort(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_stable_sort()
|
|
//
|
|
// Container-based version of the <algorithm> `std::stable_sort()` function
|
|
// to sort elements in ascending order of their values, preserving the order
|
|
// of equivalents.
|
|
template <typename C>
|
|
void c_stable_sort(C& c) {
|
|
std::stable_sort(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_stable_sort() for performing a `comp` comparison other than the
|
|
// default `operator<`.
|
|
template <typename C, typename Compare>
|
|
void c_stable_sort(C& c, Compare&& comp) {
|
|
std::stable_sort(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_is_sorted()
|
|
//
|
|
// Container-based version of the <algorithm> `std::is_sorted()` function
|
|
// to evaluate whether the given container is sorted in ascending order.
|
|
template <typename C>
|
|
bool c_is_sorted(const C& c) {
|
|
return std::is_sorted(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// c_is_sorted() overload for performing a `comp` comparison other than the
|
|
// default `operator<`.
|
|
template <typename C, typename Compare>
|
|
bool c_is_sorted(const C& c, Compare&& comp) {
|
|
return std::is_sorted(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_partial_sort()
|
|
//
|
|
// Container-based version of the <algorithm> `std::partial_sort()` function
|
|
// to rearrange elements within a container such that elements before `middle`
|
|
// are sorted in ascending order.
|
|
template <typename RandomAccessContainer>
|
|
void c_partial_sort(
|
|
RandomAccessContainer& sequence,
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer> middle) {
|
|
std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_partial_sort() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
void c_partial_sort(
|
|
RandomAccessContainer& sequence,
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer> middle,
|
|
Compare&& comp) {
|
|
std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_partial_sort_copy()
|
|
//
|
|
// Container-based version of the <algorithm> `std::partial_sort_copy()`
|
|
// function to sort elements within a container such that elements before
|
|
// `middle` are sorted in ascending order, and return the result within an
|
|
// iterator.
|
|
template <typename C, typename RandomAccessContainer>
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer>
|
|
c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {
|
|
return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
container_algorithm_internal::c_begin(result),
|
|
container_algorithm_internal::c_end(result));
|
|
}
|
|
|
|
// Overload of c_partial_sort_copy() for performing a `comp` comparison other
|
|
// than the default `operator<`.
|
|
template <typename C, typename RandomAccessContainer, typename Compare>
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer>
|
|
c_partial_sort_copy(const C& sequence, RandomAccessContainer& result,
|
|
Compare&& comp) {
|
|
return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
container_algorithm_internal::c_begin(result),
|
|
container_algorithm_internal::c_end(result),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_is_sorted_until()
|
|
//
|
|
// Container-based version of the <algorithm> `std::is_sorted_until()` function
|
|
// to return the first element within a container that is not sorted in
|
|
// ascending order as an iterator.
|
|
template <typename C>
|
|
container_algorithm_internal::ContainerIter<C> c_is_sorted_until(C& c) {
|
|
return std::is_sorted_until(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_is_sorted_until() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename C, typename Compare>
|
|
container_algorithm_internal::ContainerIter<C> c_is_sorted_until(
|
|
C& c, Compare&& comp) {
|
|
return std::is_sorted_until(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_nth_element()
|
|
//
|
|
// Container-based version of the <algorithm> `std::nth_element()` function
|
|
// to rearrange the elements within a container such that the `nth` element
|
|
// would be in that position in an ordered sequence; other elements may be in
|
|
// any order, except that all preceding `nth` will be less than that element,
|
|
// and all following `nth` will be greater than that element.
|
|
template <typename RandomAccessContainer>
|
|
void c_nth_element(
|
|
RandomAccessContainer& sequence,
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer> nth) {
|
|
std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_nth_element() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
void c_nth_element(
|
|
RandomAccessContainer& sequence,
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer> nth,
|
|
Compare&& comp) {
|
|
std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Binary Search
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_lower_bound()
|
|
//
|
|
// Container-based version of the <algorithm> `std::lower_bound()` function
|
|
// to return an iterator pointing to the first element in a sorted container
|
|
// which does not compare less than `value`.
|
|
template <typename Sequence, typename T>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
|
|
Sequence& sequence, T&& value) {
|
|
return std::lower_bound(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// Overload of c_lower_bound() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename Sequence, typename T, typename Compare>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
|
|
Sequence& sequence, T&& value, Compare&& comp) {
|
|
return std::lower_bound(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value), std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_upper_bound()
|
|
//
|
|
// Container-based version of the <algorithm> `std::upper_bound()` function
|
|
// to return an iterator pointing to the first element in a sorted container
|
|
// which is greater than `value`.
|
|
template <typename Sequence, typename T>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
|
|
Sequence& sequence, T&& value) {
|
|
return std::upper_bound(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// Overload of c_upper_bound() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename Sequence, typename T, typename Compare>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
|
|
Sequence& sequence, T&& value, Compare&& comp) {
|
|
return std::upper_bound(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value), std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_equal_range()
|
|
//
|
|
// Container-based version of the <algorithm> `std::equal_range()` function
|
|
// to return an iterator pair pointing to the first and last elements in a
|
|
// sorted container which compare equal to `value`.
|
|
template <typename Sequence, typename T>
|
|
container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
|
|
c_equal_range(Sequence& sequence, T&& value) {
|
|
return std::equal_range(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// Overload of c_equal_range() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename Sequence, typename T, typename Compare>
|
|
container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
|
|
c_equal_range(Sequence& sequence, T&& value, Compare&& comp) {
|
|
return std::equal_range(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value), std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_binary_search()
|
|
//
|
|
// Container-based version of the <algorithm> `std::binary_search()` function
|
|
// to test if any element in the sorted container contains a value equivalent to
|
|
// 'value'.
|
|
template <typename Sequence, typename T>
|
|
bool c_binary_search(Sequence&& sequence, T&& value) {
|
|
return std::binary_search(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value));
|
|
}
|
|
|
|
// Overload of c_binary_search() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename Sequence, typename T, typename Compare>
|
|
bool c_binary_search(Sequence&& sequence, T&& value, Compare&& comp) {
|
|
return std::binary_search(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Merge functions
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_merge()
|
|
//
|
|
// Container-based version of the <algorithm> `std::merge()` function
|
|
// to merge two sorted containers into a single sorted iterator.
|
|
template <typename C1, typename C2, typename OutputIterator>
|
|
OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result) {
|
|
return std::merge(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), result);
|
|
}
|
|
|
|
// Overload of c_merge() for performing a `comp` comparison other than
|
|
// the default `operator<`.
|
|
template <typename C1, typename C2, typename OutputIterator, typename Compare>
|
|
OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result,
|
|
Compare&& comp) {
|
|
return std::merge(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), result,
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_inplace_merge()
|
|
//
|
|
// Container-based version of the <algorithm> `std::inplace_merge()` function
|
|
// to merge a supplied iterator `middle` into a container.
|
|
template <typename C>
|
|
void c_inplace_merge(C& c,
|
|
container_algorithm_internal::ContainerIter<C> middle) {
|
|
std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_inplace_merge() for performing a merge using a `comp` other
|
|
// than `operator<`.
|
|
template <typename C, typename Compare>
|
|
void c_inplace_merge(C& c,
|
|
container_algorithm_internal::ContainerIter<C> middle,
|
|
Compare&& comp) {
|
|
std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_includes()
|
|
//
|
|
// Container-based version of the <algorithm> `std::includes()` function
|
|
// to test whether a sorted container `c1` entirely contains another sorted
|
|
// container `c2`.
|
|
template <typename C1, typename C2>
|
|
bool c_includes(const C1& c1, const C2& c2) {
|
|
return std::includes(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2));
|
|
}
|
|
|
|
// Overload of c_includes() for performing a merge using a `comp` other than
|
|
// `operator<`.
|
|
template <typename C1, typename C2, typename Compare>
|
|
bool c_includes(const C1& c1, const C2& c2, Compare&& comp) {
|
|
return std::includes(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_set_union()
|
|
//
|
|
// Container-based version of the <algorithm> `std::set_union()` function
|
|
// to return an iterator containing the union of two containers; duplicate
|
|
// values are not copied into the output.
|
|
template <typename C1, typename C2, typename OutputIterator,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output) {
|
|
return std::set_union(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output);
|
|
}
|
|
|
|
// Overload of c_set_union() for performing a merge using a `comp` other than
|
|
// `operator<`.
|
|
template <typename C1, typename C2, typename OutputIterator, typename Compare,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output,
|
|
Compare&& comp) {
|
|
return std::set_union(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output,
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_set_intersection()
|
|
//
|
|
// Container-based version of the <algorithm> `std::set_intersection()` function
|
|
// to return an iterator containing the intersection of two containers.
|
|
template <typename C1, typename C2, typename OutputIterator,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_intersection(const C1& c1, const C2& c2,
|
|
OutputIterator output) {
|
|
return std::set_intersection(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output);
|
|
}
|
|
|
|
// Overload of c_set_intersection() for performing a merge using a `comp` other
|
|
// than `operator<`.
|
|
template <typename C1, typename C2, typename OutputIterator, typename Compare,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_intersection(const C1& c1, const C2& c2,
|
|
OutputIterator output, Compare&& comp) {
|
|
return std::set_intersection(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output,
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_set_difference()
|
|
//
|
|
// Container-based version of the <algorithm> `std::set_difference()` function
|
|
// to return an iterator containing elements present in the first container but
|
|
// not in the second.
|
|
template <typename C1, typename C2, typename OutputIterator,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_difference(const C1& c1, const C2& c2,
|
|
OutputIterator output) {
|
|
return std::set_difference(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output);
|
|
}
|
|
|
|
// Overload of c_set_difference() for performing a merge using a `comp` other
|
|
// than `operator<`.
|
|
template <typename C1, typename C2, typename OutputIterator, typename Compare,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_difference(const C1& c1, const C2& c2,
|
|
OutputIterator output, Compare&& comp) {
|
|
return std::set_difference(container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output,
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_set_symmetric_difference()
|
|
//
|
|
// Container-based version of the <algorithm> `std::set_symmetric_difference()`
|
|
// function to return an iterator containing elements present in either one
|
|
// container or the other, but not both.
|
|
template <typename C1, typename C2, typename OutputIterator,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
|
|
OutputIterator output) {
|
|
return std::set_symmetric_difference(
|
|
container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output);
|
|
}
|
|
|
|
// Overload of c_set_symmetric_difference() for performing a merge using a
|
|
// `comp` other than `operator<`.
|
|
template <typename C1, typename C2, typename OutputIterator, typename Compare,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
|
|
void>::type,
|
|
typename = typename std::enable_if<
|
|
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
|
|
void>::type>
|
|
OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
|
|
OutputIterator output,
|
|
Compare&& comp) {
|
|
return std::set_symmetric_difference(
|
|
container_algorithm_internal::c_begin(c1),
|
|
container_algorithm_internal::c_end(c1),
|
|
container_algorithm_internal::c_begin(c2),
|
|
container_algorithm_internal::c_end(c2), output,
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Heap functions
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_push_heap()
|
|
//
|
|
// Container-based version of the <algorithm> `std::push_heap()` function
|
|
// to push a value onto a container heap.
|
|
template <typename RandomAccessContainer>
|
|
void c_push_heap(RandomAccessContainer& sequence) {
|
|
std::push_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_push_heap() for performing a push operation on a heap using a
|
|
// `comp` other than `operator<`.
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
void c_push_heap(RandomAccessContainer& sequence, Compare&& comp) {
|
|
std::push_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_pop_heap()
|
|
//
|
|
// Container-based version of the <algorithm> `std::pop_heap()` function
|
|
// to pop a value from a heap container.
|
|
template <typename RandomAccessContainer>
|
|
void c_pop_heap(RandomAccessContainer& sequence) {
|
|
std::pop_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_pop_heap() for performing a pop operation on a heap using a
|
|
// `comp` other than `operator<`.
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
void c_pop_heap(RandomAccessContainer& sequence, Compare&& comp) {
|
|
std::pop_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_make_heap()
|
|
//
|
|
// Container-based version of the <algorithm> `std::make_heap()` function
|
|
// to make a container a heap.
|
|
template <typename RandomAccessContainer>
|
|
void c_make_heap(RandomAccessContainer& sequence) {
|
|
std::make_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_make_heap() for performing heap comparisons using a
|
|
// `comp` other than `operator<`
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
void c_make_heap(RandomAccessContainer& sequence, Compare&& comp) {
|
|
std::make_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_sort_heap()
|
|
//
|
|
// Container-based version of the <algorithm> `std::sort_heap()` function
|
|
// to sort a heap into ascending order (after which it is no longer a heap).
|
|
template <typename RandomAccessContainer>
|
|
void c_sort_heap(RandomAccessContainer& sequence) {
|
|
std::sort_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_sort_heap() for performing heap comparisons using a
|
|
// `comp` other than `operator<`
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
void c_sort_heap(RandomAccessContainer& sequence, Compare&& comp) {
|
|
std::sort_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_is_heap()
|
|
//
|
|
// Container-based version of the <algorithm> `std::is_heap()` function
|
|
// to check whether the given container is a heap.
|
|
template <typename RandomAccessContainer>
|
|
bool c_is_heap(const RandomAccessContainer& sequence) {
|
|
return std::is_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_is_heap() for performing heap comparisons using a
|
|
// `comp` other than `operator<`
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
bool c_is_heap(const RandomAccessContainer& sequence, Compare&& comp) {
|
|
return std::is_heap(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_is_heap_until()
|
|
//
|
|
// Container-based version of the <algorithm> `std::is_heap_until()` function
|
|
// to find the first element in a given container which is not in heap order.
|
|
template <typename RandomAccessContainer>
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer>
|
|
c_is_heap_until(RandomAccessContainer& sequence) {
|
|
return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_is_heap_until() for performing heap comparisons using a
|
|
// `comp` other than `operator<`
|
|
template <typename RandomAccessContainer, typename Compare>
|
|
container_algorithm_internal::ContainerIter<RandomAccessContainer>
|
|
c_is_heap_until(RandomAccessContainer& sequence, Compare&& comp) {
|
|
return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Min/max
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_min_element()
|
|
//
|
|
// Container-based version of the <algorithm> `std::min_element()` function
|
|
// to return an iterator pointing to the element with the smallest value, using
|
|
// `operator<` to make the comparisons.
|
|
template <typename Sequence>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_min_element(
|
|
Sequence& sequence) {
|
|
return std::min_element(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_min_element() for performing a `comp` comparison other than
|
|
// `operator<`.
|
|
template <typename Sequence, typename Compare>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_min_element(
|
|
Sequence& sequence, Compare&& comp) {
|
|
return std::min_element(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_max_element()
|
|
//
|
|
// Container-based version of the <algorithm> `std::max_element()` function
|
|
// to return an iterator pointing to the element with the largest value, using
|
|
// `operator<` to make the comparisons.
|
|
template <typename Sequence>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_max_element(
|
|
Sequence& sequence) {
|
|
return std::max_element(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence));
|
|
}
|
|
|
|
// Overload of c_max_element() for performing a `comp` comparison other than
|
|
// `operator<`.
|
|
template <typename Sequence, typename Compare>
|
|
container_algorithm_internal::ContainerIter<Sequence> c_max_element(
|
|
Sequence& sequence, Compare&& comp) {
|
|
return std::max_element(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_minmax_element()
|
|
//
|
|
// Container-based version of the <algorithm> `std::minmax_element()` function
|
|
// to return a pair of iterators pointing to the elements containing the
|
|
// smallest and largest values, respectively, using `operator<` to make the
|
|
// comparisons.
|
|
template <typename C>
|
|
container_algorithm_internal::ContainerIterPairType<C, C>
|
|
c_minmax_element(C& c) {
|
|
return std::minmax_element(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_minmax_element() for performing `comp` comparisons other than
|
|
// `operator<`.
|
|
template <typename C, typename Compare>
|
|
container_algorithm_internal::ContainerIterPairType<C, C>
|
|
c_minmax_element(C& c, Compare&& comp) {
|
|
return std::minmax_element(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <algorithm> Lexicographical Comparisons
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_lexicographical_compare()
|
|
//
|
|
// Container-based version of the <algorithm> `std::lexicographical_compare()`
|
|
// function to lexicographically compare (e.g. sort words alphabetically) two
|
|
// container sequences. The comparison is performed using `operator<`. Note
|
|
// that capital letters ("A-Z") have ASCII values less than lowercase letters
|
|
// ("a-z").
|
|
template <typename Sequence1, typename Sequence2>
|
|
bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2) {
|
|
return std::lexicographical_compare(
|
|
container_algorithm_internal::c_begin(sequence1),
|
|
container_algorithm_internal::c_end(sequence1),
|
|
container_algorithm_internal::c_begin(sequence2),
|
|
container_algorithm_internal::c_end(sequence2));
|
|
}
|
|
|
|
// Overload of c_lexicographical_compare() for performing a lexicographical
|
|
// comparison using a `comp` operator instead of `operator<`.
|
|
template <typename Sequence1, typename Sequence2, typename Compare>
|
|
bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2,
|
|
Compare&& comp) {
|
|
return std::lexicographical_compare(
|
|
container_algorithm_internal::c_begin(sequence1),
|
|
container_algorithm_internal::c_end(sequence1),
|
|
container_algorithm_internal::c_begin(sequence2),
|
|
container_algorithm_internal::c_end(sequence2),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_next_permutation()
|
|
//
|
|
// Container-based version of the <algorithm> `std::next_permutation()` function
|
|
// to rearrange a container's elements into the next lexicographically greater
|
|
// permutation.
|
|
template <typename C>
|
|
bool c_next_permutation(C& c) {
|
|
return std::next_permutation(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_next_permutation() for performing a lexicographical
|
|
// comparison using a `comp` operator instead of `operator<`.
|
|
template <typename C, typename Compare>
|
|
bool c_next_permutation(C& c, Compare&& comp) {
|
|
return std::next_permutation(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
// c_prev_permutation()
|
|
//
|
|
// Container-based version of the <algorithm> `std::prev_permutation()` function
|
|
// to rearrange a container's elements into the next lexicographically lesser
|
|
// permutation.
|
|
template <typename C>
|
|
bool c_prev_permutation(C& c) {
|
|
return std::prev_permutation(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c));
|
|
}
|
|
|
|
// Overload of c_prev_permutation() for performing a lexicographical
|
|
// comparison using a `comp` operator instead of `operator<`.
|
|
template <typename C, typename Compare>
|
|
bool c_prev_permutation(C& c, Compare&& comp) {
|
|
return std::prev_permutation(container_algorithm_internal::c_begin(c),
|
|
container_algorithm_internal::c_end(c),
|
|
std::forward<Compare>(comp));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// <numeric> algorithms
|
|
//------------------------------------------------------------------------------
|
|
|
|
// c_iota()
|
|
//
|
|
// Container-based version of the <algorithm> `std::iota()` function
|
|
// to compute successive values of `value`, as if incremented with `++value`
|
|
// after each element is written. and write them to the container.
|
|
template <typename Sequence, typename T>
|
|
void c_iota(Sequence& sequence, T&& value) {
|
|
std::iota(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(value));
|
|
}
|
|
// c_accumulate()
|
|
//
|
|
// Container-based version of the <algorithm> `std::accumulate()` function
|
|
// to accumulate the element values of a container to `init` and return that
|
|
// accumulation by value.
|
|
//
|
|
// Note: Due to a language technicality this function has return type
|
|
// absl::decay_t<T>. As a user of this function you can casually read
|
|
// this as "returns T by value" and assume it does the right thing.
|
|
template <typename Sequence, typename T>
|
|
decay_t<T> c_accumulate(const Sequence& sequence, T&& init) {
|
|
return std::accumulate(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(init));
|
|
}
|
|
|
|
// Overload of c_accumulate() for using a binary operations other than
|
|
// addition for computing the accumulation.
|
|
template <typename Sequence, typename T, typename BinaryOp>
|
|
decay_t<T> c_accumulate(const Sequence& sequence, T&& init,
|
|
BinaryOp&& binary_op) {
|
|
return std::accumulate(container_algorithm_internal::c_begin(sequence),
|
|
container_algorithm_internal::c_end(sequence),
|
|
std::forward<T>(init),
|
|
std::forward<BinaryOp>(binary_op));
|
|
}
|
|
|
|
// c_inner_product()
|
|
//
|
|
// Container-based version of the <algorithm> `std::inner_product()` function
|
|
// to compute the cumulative inner product of container element pairs.
|
|
//
|
|
// Note: Due to a language technicality this function has return type
|
|
// absl::decay_t<T>. As a user of this function you can casually read
|
|
// this as "returns T by value" and assume it does the right thing.
|
|
template <typename Sequence1, typename Sequence2, typename T>
|
|
decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
|
|
T&& sum) {
|
|
return std::inner_product(container_algorithm_internal::c_begin(factors1),
|
|
container_algorithm_internal::c_end(factors1),
|
|
container_algorithm_internal::c_begin(factors2),
|
|
std::forward<T>(sum));
|
|
}
|
|
|
|
// Overload of c_inner_product() for using binary operations other than
|
|
// `operator+` (for computing the accumulation) and `operator*` (for computing
|
|
// the product between the two container's element pair).
|
|
template <typename Sequence1, typename Sequence2, typename T,
|
|
typename BinaryOp1, typename BinaryOp2>
|
|
decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
|
|
T&& sum, BinaryOp1&& op1, BinaryOp2&& op2) {
|
|
return std::inner_product(container_algorithm_internal::c_begin(factors1),
|
|
container_algorithm_internal::c_end(factors1),
|
|
container_algorithm_internal::c_begin(factors2),
|
|
std::forward<T>(sum), std::forward<BinaryOp1>(op1),
|
|
std::forward<BinaryOp2>(op2));
|
|
}
|
|
|
|
// c_adjacent_difference()
|
|
//
|
|
// Container-based version of the <algorithm> `std::adjacent_difference()`
|
|
// function to compute the difference between each element and the one preceding
|
|
// it and write it to an iterator.
|
|
template <typename InputSequence, typename OutputIt>
|
|
OutputIt c_adjacent_difference(const InputSequence& input,
|
|
OutputIt output_first) {
|
|
return std::adjacent_difference(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input),
|
|
output_first);
|
|
}
|
|
|
|
// Overload of c_adjacent_difference() for using a binary operation other than
|
|
// subtraction to compute the adjacent difference.
|
|
template <typename InputSequence, typename OutputIt, typename BinaryOp>
|
|
OutputIt c_adjacent_difference(const InputSequence& input,
|
|
OutputIt output_first, BinaryOp&& op) {
|
|
return std::adjacent_difference(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input),
|
|
output_first, std::forward<BinaryOp>(op));
|
|
}
|
|
|
|
// c_partial_sum()
|
|
//
|
|
// Container-based version of the <algorithm> `std::partial_sum()` function
|
|
// to compute the partial sum of the elements in a sequence and write them
|
|
// to an iterator. The partial sum is the sum of all element values so far in
|
|
// the sequence.
|
|
template <typename InputSequence, typename OutputIt>
|
|
OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first) {
|
|
return std::partial_sum(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input),
|
|
output_first);
|
|
}
|
|
|
|
// Overload of c_partial_sum() for using a binary operation other than addition
|
|
// to compute the "partial sum".
|
|
template <typename InputSequence, typename OutputIt, typename BinaryOp>
|
|
OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first,
|
|
BinaryOp&& op) {
|
|
return std::partial_sum(container_algorithm_internal::c_begin(input),
|
|
container_algorithm_internal::c_end(input),
|
|
output_first, std::forward<BinaryOp>(op));
|
|
}
|
|
|
|
} // namespace absl
|
|
|
|
#endif // ABSL_ALGORITHM_CONTAINER_H_
|