srctree

Robin Linden parent 657907d7 618ece5d
all: Switch to std::ranges versions of algorithms

Fewer function calls, less typing, easier to read. Pretty neat!

I found these ones by manually going through the files in which weinclude <algorithm> to see if there was anything with a cooleralternative in the std::ranges namespace.
inlinesplit
css/parser.h added: 34, removed: 40, total 0
@@ -13,6 +13,7 @@
#include <fmt/format.h>
#include <spdlog/spdlog.h>
 
#include <algorithm>
#include <array>
#include <charconv>
#include <cstring>
@@ -425,7 +426,7 @@ private:
 
template<auto const &array>
constexpr bool is_in_array(std::string_view str) const {
return std::find(std::cbegin(array), std::cend(array), str) != std::cend(array);
return std::ranges::find(array, str) != std::cend(array);
}
 
constexpr bool is_shorthand_edge_property(std::string_view str) const {
 
css/parser_test.cpp added: 34, removed: 40, total 0
@@ -23,7 +23,7 @@ using etest::require_eq;
namespace {
 
[[maybe_unused]] std::ostream &operator<<(std::ostream &os, std::vector<std::string> const &vec) {
std::copy(cbegin(vec), cend(vec), std::ostream_iterator<std::string const &>(os, " "));
std::ranges::copy(vec, std::ostream_iterator<std::string const &>(os, " "));
return os;
}
 
@@ -37,7 +37,7 @@ auto const initial_background_values = std::map<std::string, std::string, std::l
{"background-color", "transparent"}};
 
bool check_initial_background_values(std::map<std::string, std::string, std::less<>> const &declarations) {
return std::all_of(cbegin(declarations), cend(declarations), [](auto const &decl) {
return std::ranges::all_of(declarations, [](auto const &decl) {
auto it = initial_background_values.find(decl.first);
return it != cend(initial_background_values) && it->second == decl.second;
});
@@ -63,7 +63,7 @@ auto const initial_font_values = std::map<std::string, std::string, std::less<>>
{"font-variant-east-asian", "normal"}};
 
bool check_initial_font_values(std::map<std::string, std::string, std::less<>> const &declarations) {
return std::all_of(cbegin(declarations), cend(declarations), [](auto const &decl) {
return std::ranges::all_of(declarations, [](auto const &decl) {
auto it = initial_font_values.find(decl.first);
return it != cend(initial_font_values) && it->second == decl.second;
});
 
etest/etest.cpp added: 34, removed: 40, total 0
@@ -42,6 +42,8 @@ int run_all_tests() noexcept {
std::cout << ", " << disabled_tests << " disabled." << std::endl;
}
 
// TODO(robinlinden): std::ranges once clang-cl supports it. Last tested
// with LLVM 15.0.0.
auto const longest_name = std::max_element(registry().begin(), registry().end(), [](auto const &a, auto const &b) {
return a.name.size() < b.name.size();
});
 
html/parser.cpp added: 34, removed: 40, total 0
@@ -22,7 +22,7 @@ namespace {
 
template<auto const &array>
constexpr bool is_in_array(std::string_view str) {
return std::find(std::cbegin(array), std::cend(array), str) != std::cend(array);
return std::ranges::find(array, str) != std::cend(array);
}
 
dom::AttrMap into_dom_attributes(std::vector<html2::Attribute> const &attributes) {
@@ -126,7 +126,7 @@ void Parser::operator()(html2::EndOfFileToken const &) {
void Parser::generate_text_node_if_needed() {
assert(!open_elements_.empty());
auto text = std::exchange(current_text_, {}).str();
bool is_uninteresting = std::all_of(cbegin(text), cend(text), [](char c) { return util::is_whitespace(c); });
bool is_uninteresting = std::ranges::all_of(text, [](char c) { return util::is_whitespace(c); });
if (is_uninteresting) {
return;
}
 
protocol/response.cpp added: 34, removed: 40, total 0
@@ -37,9 +37,8 @@ std::size_t Headers::size() const {
}
 
bool Headers::CaseInsensitiveLess::operator()(std::string_view s1, std::string_view s2) const {
return std::lexicographical_compare(begin(s1), end(s1), begin(s2), end(s2), [](char c1, char c2) {
return util::lowercased(c1) < util::lowercased(c2);
});
return std::ranges::lexicographical_compare(
s1, s2, [](char c1, char c2) { return util::lowercased(c1) < util::lowercased(c2); });
}
 
} // namespace protocol
 
render/render.cpp added: 34, removed: 40, total 0
@@ -29,9 +29,8 @@ constexpr gfx::Color kDefaultColor{0x0, 0x0, 0x0};
struct CaseInsensitiveLess {
using is_transparent = void;
bool operator()(std::string_view s1, std::string_view s2) const {
return std::lexicographical_compare(begin(s1), end(s1), begin(s2), end(s2), [](char c1, char c2) {
return util::lowercased(c1) < util::lowercased(c2);
});
return std::ranges::lexicographical_compare(
s1, s2, [](char c1, char c2) { return util::lowercased(c1) < util::lowercased(c2); });
}
};
 
 
style/style.cpp added: 34, removed: 40, total 0
@@ -62,10 +62,8 @@ std::vector<std::pair<std::string, std::string>> matching_rules(
std::vector<std::pair<std::string, std::string>> matched_rules;
 
for (auto const &rule : stylesheet) {
if (std::any_of(rule.selectors.cbegin(), rule.selectors.cend(), [&](auto const &selector) {
return is_match(element, selector);
})) {
std::copy(rule.declarations.cbegin(), rule.declarations.cend(), std::back_inserter(matched_rules));
if (std::ranges::any_of(rule.selectors, [&](auto const &selector) { return is_match(element, selector); })) {
std::ranges::copy(rule.declarations, std::back_inserter(matched_rules));
}
}
 
 
style/style_test.cpp added: 34, removed: 40, total 0
@@ -19,7 +19,7 @@ using etest::require;
 
namespace {
bool check_parents(style::StyledNode const &a, style::StyledNode const &b) {
if (!std::equal(cbegin(a.children), cend(a.children), cbegin(b.children), cend(b.children), &check_parents)) {
if (!std::ranges::equal(a.children, b.children, &check_parents)) {
return false;
}
 
 
style/styled_node.cpp added: 34, removed: 40, total 0
@@ -58,7 +58,7 @@ constexpr std::array kInheritedProperties{
 
template<auto const &array>
constexpr bool is_in_array(std::string_view str) {
return std::find(std::cbegin(array), std::cend(array), str) != std::cend(array);
return std::ranges::find(array, str) != std::cend(array);
}
 
constexpr bool is_inherited(std::string_view property) {
@@ -85,8 +85,7 @@ std::optional<std::string_view> get_parent_property(style::StyledNode const &nod
} // namespace
 
std::optional<std::string_view> get_property(style::StyledNode const &node, std::string_view property) {
auto it = std::find_if(
cbegin(node.properties), cend(node.properties), [=](auto const &p) { return p.first == property; });
auto it = std::ranges::find_if(node.properties, [=](auto const &p) { return p.first == property; });
 
if (it == cend(node.properties)) {
if (is_inherited(property) && node.parent != nullptr) {
 
util/base_parser.h added: 34, removed: 40, total 0
@@ -49,10 +49,7 @@ public:
 
private:
static constexpr auto space_chars = std::array{' ', '\f', '\n', '\r', '\t', '\v'};
 
constexpr static bool is_space(char c) {
return std::find(begin(space_chars), end(space_chars), c) != end(space_chars);
}
constexpr static bool is_space(char c) { return std::ranges::find(space_chars, c) != end(space_chars); }
 
std::string_view input_;
std::size_t pos_{0};
 
util/string.h added: 34, removed: 40, total 0
@@ -56,13 +56,12 @@ constexpr char lowercased(char c) {
}
 
[[nodiscard]] inline std::string lowercased(std::string s) {
std::transform(begin(s), end(s), begin(s), [](char c) { return lowercased(c); });
std::ranges::transform(std::move(s), begin(s), [](char c) { return lowercased(c); });
return s;
}
 
constexpr bool no_case_compare(std::string_view a, std::string_view b) {
return std::equal(
begin(a), end(a), begin(b), end(b), [](auto c1, auto c2) { return lowercased(c1) == lowercased(c2); });
return std::ranges::equal(a, b, [](auto c1, auto c2) { return lowercased(c1) == lowercased(c2); });
}
 
inline std::vector<std::string_view> split(std::string_view str, std::string_view sep) {
@@ -84,11 +83,11 @@ inline std::pair<std::string_view, std::string_view> split_once(std::string_view
 
constexpr bool is_whitespace(char ch) {
constexpr std::array ws_chars = {' ', '\n', '\r', '\f', '\v', '\t'};
return std::any_of(cbegin(ws_chars), cend(ws_chars), [ch](char ws_ch) { return ch == ws_ch; });
return std::ranges::any_of(ws_chars, [ch](char ws_ch) { return ch == ws_ch; });
}
 
constexpr std::string_view trim_start(std::string_view s) {
auto it = std::find_if(cbegin(s), cend(s), [](char ch) { return !is_whitespace(ch); });
auto it = std::ranges::find_if(s, [](char ch) { return !is_whitespace(ch); });
s.remove_prefix(std::distance(cbegin(s), it));
return s;
}