beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-21 23:20:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/AK/AllOf.h

36 lines
791 B
C
Raw Normal View History

AK: Implement generic all_of algorithm Problem: - Raw loops are often written to validate that all values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `all_of`.
2020-11-17 01:27:14 +00:00
/*
* Copyright (c) 2020, the SerenityOS developers.
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
AK: Implement generic all_of algorithm Problem: - Raw loops are often written to validate that all values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `all_of`.
2020-11-17 01:27:14 +00:00
*/
#pragma once
AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version).
2021-07-22 14:41:00 +00:00
#include <AK/Concepts.h>
AK: Reimplement all_of in terms of find_if Problem: - Now that a generic free-function form of `find_if` is implemented the code in `all_of` is redundant. Solution: - Follow the "don't repeat yourself" mantra and make the code DRY by implementing `all_of` in terms of `find_if`. - One tricky part is that since captures are not permitted in `constexpr` lambdas, the lambda created to negate the predicate needs to be created by a function which does not capture and takes the predicate at run-time instead. This allows `all_of` to continue to work in a `constexpr` context.
2021-06-24 16:24:13 +00:00
#include <AK/Find.h>
AllOf: Common iterator types Problem: - Interface is too permissive. It permits iterators of different types as long as they are comparable. Solution: - Require iterators be the same type.
2020-11-23 00:09:44 +00:00
#include <AK/Iterator.h>
AK: Implement generic all_of algorithm Problem: - Raw loops are often written to validate that all values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `all_of`.
2020-11-17 01:27:14 +00:00
namespace AK {
AK: Rewrite {AnyOf,AllOf,Find}.h to use the IteratorPairWith concept This makes it so these algorithms are usable with arbitrary iterators, as opposed to just instances of AK::SimpleIterator. This commit also makes the requirement of ::index() in find_index() explicit, as previously it was accepting any iterator.
2021-07-22 14:49:34 +00:00
template<typename TEndIterator, IteratorPairWith<TEndIterator> TIterator>
AllOf: Common iterator types Problem: - Interface is too permissive. It permits iterators of different types as long as they are comparable. Solution: - Require iterators be the same type.
2020-11-23 00:09:44 +00:00
constexpr bool all_of(
AK: Rewrite {AnyOf,AllOf,Find}.h to use the IteratorPairWith concept This makes it so these algorithms are usable with arbitrary iterators, as opposed to just instances of AK::SimpleIterator. This commit also makes the requirement of ::index() in find_index() explicit, as previously it was accepting any iterator.
2021-07-22 14:49:34 +00:00
TIterator const& begin,
TEndIterator const& end,
AK: Convert AnyOf/AllOf to east-const style
2021-07-22 14:43:56 +00:00
auto const& predicate)
AK: Implement generic all_of algorithm Problem: - Raw loops are often written to validate that all values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `all_of`.
2020-11-17 01:27:14 +00:00
{
AK: Reimplement all_of in terms of find_if Problem: - Now that a generic free-function form of `find_if` is implemented the code in `all_of` is redundant. Solution: - Follow the "don't repeat yourself" mantra and make the code DRY by implementing `all_of` in terms of `find_if`. - One tricky part is that since captures are not permitted in `constexpr` lambdas, the lambda created to negate the predicate needs to be created by a function which does not capture and takes the predicate at run-time instead. This allows `all_of` to continue to work in a `constexpr` context.
2021-06-24 16:24:13 +00:00
constexpr auto negated_predicate = [](auto const& pred) {
return [&](auto const& elem) { return !pred(elem); };
};
return !(find_if(begin, end, negated_predicate(predicate)) != end);
AK: Implement generic all_of algorithm Problem: - Raw loops are often written to validate that all values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `all_of`.
2020-11-17 01:27:14 +00:00
}
AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version).
2021-07-22 14:41:00 +00:00
template<IterableContainer Container>
constexpr bool all_of(Container&& container, auto const& predicate)
{
AK: Reimplement all_of in terms of find_if Problem: - Now that a generic free-function form of `find_if` is implemented the code in `all_of` is redundant. Solution: - Follow the "don't repeat yourself" mantra and make the code DRY by implementing `all_of` in terms of `find_if`. - One tricky part is that since captures are not permitted in `constexpr` lambdas, the lambda created to negate the predicate needs to be created by a function which does not capture and takes the predicate at run-time instead. This allows `all_of` to continue to work in a `constexpr` context.
2021-06-24 16:24:13 +00:00
return all_of(container.begin(), container.end(), predicate);
AK: Implement {any,all}_of(IterableContainer&&, Predicate) This is a generally nicer-to-use version of the existing {any,all}_of() that doesn't require the user to explicitly provide two iterators. As a bonus, it also allows arbitrary iterators (as opposed to the hard requirement of providing SimpleIterators in the iterator version).
2021-07-22 14:41:00 +00:00
}
AK: Implement generic all_of algorithm Problem: - Raw loops are often written to validate that all values in a container meet a predicate, but raw loops are not as expressive as functions implementing well-named algorithms and are error-prone. Solution: - Implement a very generic form of `all_of`.
2020-11-17 01:27:14 +00:00
}
AK: Publish all_of()
2021-02-17 10:07:01 +00:00
using AK::all_of;
Reference in a new issue Copy permalink