Skip to content
This repository was archived by the owner on May 12, 2020. It is now read-only.

Commit 76bdb66

Browse files
pes10kpes10k
committed
linter fixes / cleanup
1 parent d4a9635 commit 76bdb66

13 files changed

Lines changed: 75 additions & 75 deletions

‎etld/domain.cc‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -9,14 +9,14 @@
99

1010
namespace brave_etld {
1111

12-
Domain::Domain(const Domain &domain) :
12+
Domain::Domain(const Domain& domain) :
1313
labels_(domain.labels_) {}
1414

15-
Domain::Domain(const std::vector<Label> &labels) :
15+
Domain::Domain(const std::vector<Label>& labels) :
1616
labels_(labels) {}
1717

18-
Domain::Domain(const std::string &string) {
19-
std::size_t current, previous = 0;
18+
Domain::Domain(const std::string& string) {
19+
size_t current, previous = 0;
2020
current = string.find(".");
2121
if (current == std::string::npos) {
2222
labels_.push_back(string);
@@ -34,7 +34,7 @@ Domain::Domain(const std::string &string) {
3434
}
3535
}
3636

37-
bool Domain::Equals(const Domain &domain) {
37+
bool Domain::Equals(const Domain& domain) {
3838
const size_t local_length = Length();
3939
if (local_length != domain.Length()) {
4040
return false;

‎etld/domain.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,9 @@ namespace brave_etld {
1414

1515
class Domain {
1616
public:
17-
explicit Domain(const Domain &domain);
18-
explicit Domain(const std::string &domain);
19-
explicit Domain(const std::vector<Label> &labels);
17+
explicit Domain(const Domain& domain);
18+
explicit Domain(const std::string& domain);
19+
explicit Domain(const std::vector<Label>& labels);
2020

2121
bool Equals(const Domain &domain);
2222

‎etld/internal/parser.cc‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ namespace internal {
1717
PublicSuffixParseResult::PublicSuffixParseResult() {}
1818

1919
PublicSuffixParseResult::PublicSuffixParseResult(
20-
const PublicSuffixParseResult &results) :
20+
const PublicSuffixParseResult& results) :
2121
num_whitespace_lines_(results.num_whitespace_lines_),
2222
num_comment_lines_(results.num_comment_lines_),
2323
num_invalid_rules_(results.num_invalid_rules_),
@@ -28,7 +28,7 @@ const std::vector<PublicSuffixRule>& PublicSuffixParseResult::Rules() const {
2828
}
2929

3030
void PublicSuffixParseResult::ConsumeParseResult(
31-
const PublicSuffixTextLineParseResult &result) {
31+
const PublicSuffixTextLineParseResult& result) {
3232
switch (result.type) {
3333
case PublicSuffixTextLineTypeRule:
3434
rules_.push_back(*(result.rule));
@@ -52,17 +52,17 @@ void PublicSuffixParseResult::ConsumeParseResult(
5252
}
5353
}
5454

55-
PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file) {
55+
PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file) {
5656
std::string line;
5757
PublicSuffixParseResult results;
58-
while (std::getline(rule_file, line)) {
58+
while (std::getline(*rule_file, line)) {
5959
results.ConsumeParseResult(parse_rule_line(line));
6060
}
6161

6262
return results;
6363
}
6464

65-
PublicSuffixParseResult parse_rule_text(const std::string &text) {
65+
PublicSuffixParseResult parse_rule_text(const std::string& text) {
6666
std::istringstream stream(text);
6767
std::string line;
6868
PublicSuffixParseResult results;
@@ -73,7 +73,7 @@ PublicSuffixParseResult parse_rule_text(const std::string &text) {
7373
return results;
7474
}
7575

76-
PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
76+
PublicSuffixTextLineParseResult parse_rule_line(const std::string& line) {
7777
// Check to see if this is a comment line. If so, process no further.
7878
if (line.find("//") == 0) {
7979
return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
@@ -88,8 +88,7 @@ PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
8888
try {
8989
return PublicSuffixTextLineParseResult(
9090
PublicSuffixTextLineTypeRule,
91-
new PublicSuffixRule(line)
92-
);
91+
new PublicSuffixRule(line));
9392
} catch (PublicSuffixRuleInputException error) {
9493
return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeInvalidRule);
9594
}

‎etld/internal/parser.h‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ enum PublicSuffixTextLineType {
2626
struct PublicSuffixTextLineParseResult {
2727
PublicSuffixTextLineParseResult(
2828
PublicSuffixTextLineType type = PublicSuffixTextLineTypeNone,
29-
const PublicSuffixRule * rule = nullptr) :
29+
const PublicSuffixRule* rule = nullptr) :
3030
type(type),
3131
rule(rule) {}
3232
const PublicSuffixTextLineType type;
@@ -36,10 +36,10 @@ struct PublicSuffixTextLineParseResult {
3636
class PublicSuffixParseResult {
3737
public:
3838
PublicSuffixParseResult();
39-
PublicSuffixParseResult(const PublicSuffixParseResult &results);
39+
PublicSuffixParseResult(const PublicSuffixParseResult& results);
4040

4141
const std::vector<PublicSuffixRule>& Rules() const;
42-
void ConsumeParseResult(const PublicSuffixTextLineParseResult &result);
42+
void ConsumeParseResult(const PublicSuffixTextLineParseResult& result);
4343

4444
int NumWhitespaceLines() const {
4545
return num_whitespace_lines_;
@@ -62,9 +62,9 @@ class PublicSuffixParseResult {
6262

6363
// This attempts to implement the algorithm described here:
6464
// https://www.publicsuffix.org/list/
65-
PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file);
66-
PublicSuffixParseResult parse_rule_text(const std::string &rule_text);
67-
PublicSuffixTextLineParseResult parse_rule_line(const std::string &line);
65+
PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file);
66+
PublicSuffixParseResult parse_rule_text(const std::string& rule_text);
67+
PublicSuffixTextLineParseResult parse_rule_line(const std::string& line);
6868

6969
} // namespace internal
7070
} // namespace brave_etld

‎etld/internal/public_suffix_rule.cc‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,9 @@
1616
namespace brave_etld {
1717
namespace internal {
1818

19-
const PublicSuffixRule * PublicSuffixRule::root_rule = new PublicSuffixRule("*");
19+
const PublicSuffixRule* PublicSuffixRule::root_rule = new PublicSuffixRule("*");
2020

21-
std::vector<Label> parse_labels(const std::string &label_text) {
21+
std::vector<Label> parse_labels(const std::string& label_text) {
2222
std::vector<Label> labels;
2323
size_t previous = 0;
2424
size_t current = label_text.find(".");
@@ -61,12 +61,12 @@ std::string trim_to_whitespace(std::string const& str) {
6161

6262
PublicSuffixRule::PublicSuffixRule() {}
6363

64-
PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) :
64+
PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule& rule) :
6565
labels_(rule.labels_),
6666
is_exception_(rule.IsException()),
6767
is_wildcard_(rule.IsWildcard()) {}
6868

69-
PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
69+
PublicSuffixRule::PublicSuffixRule(const std::string& rule_text) {
7070
std::string trimmed_rule_text(trim_to_whitespace(rule_text));
7171
if (trimmed_rule_text.length() == 0) {
7272
throw PublicSuffixRuleInputException(
@@ -97,7 +97,7 @@ PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
9797
labels_ = parse_labels(labels_view);
9898
}
9999

100-
PublicSuffixRule::PublicSuffixRule(const std::vector<Label> &labels,
100+
PublicSuffixRule::PublicSuffixRule(const std::vector<Label>& labels,
101101
bool is_exception, bool is_wildcard) :
102102
labels_(labels),
103103
is_exception_(is_exception),
@@ -129,7 +129,7 @@ SerializationResult PublicSuffixRule::Serialize() const {
129129
};
130130
}
131131

132-
bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
132+
bool PublicSuffixRule::Equals(const PublicSuffixRule& rule) const {
133133
return (
134134
labels_ == rule.labels_ &&
135135
is_exception_ == rule.IsException() &&
@@ -138,7 +138,7 @@ bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
138138

139139
// Implements matching algoritms described here
140140
// https://publicsuffix.org/list/
141-
bool PublicSuffixRule::Matches(const Domain &domain) const {
141+
bool PublicSuffixRule::Matches(const Domain& domain) const {
142142
// When the domain and rule are split into corresponding labels, that the
143143
// domain contains as many or more labels than the rule.
144144
const size_t num_rule_labels = labels_.size();
@@ -166,8 +166,8 @@ bool PublicSuffixRule::Matches(const Domain &domain) const {
166166
return true;
167167
}
168168

169-
DomainInfo PublicSuffixRule::Apply(const Domain &domain) const {
170-
auto domain_len = domain.Length();
169+
DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
170+
const auto domain_len = domain.Length();
171171
auto rule_len = Length();
172172
if (IsException()) {
173173
rule_len -= 1;
@@ -249,7 +249,7 @@ std::string PublicSuffixRule::ToString() const {
249249
return as_string.str();
250250
}
251251

252-
PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer) {
252+
PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer) {
253253
const SerializedBufferInfo info = extract_buffer_info(buffer);
254254
const std::string body_str = buffer.substr(info.body_start, info.body_len);
255255
bool is_exception = body_str[0] == 't';

‎etld/internal/public_suffix_rule.h‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ namespace internal {
1717

1818
class PublicSuffixRuleInputException : public std::exception {
1919
public:
20-
explicit PublicSuffixRuleInputException(const char * message) :
20+
explicit PublicSuffixRuleInputException(const char* message) :
2121
msg_(message) {}
2222
explicit PublicSuffixRuleInputException(const std::string &message) :
2323
msg_(message) {}
@@ -32,20 +32,20 @@ class PublicSuffixRuleInputException : public std::exception {
3232

3333
class PublicSuffixRule {
3434
public:
35-
static const PublicSuffixRule * root_rule;
35+
static const PublicSuffixRule* root_rule;
3636
PublicSuffixRule();
37-
PublicSuffixRule(const PublicSuffixRule &rule);
38-
explicit PublicSuffixRule(const std::string &rule_text);
37+
PublicSuffixRule(const PublicSuffixRule& rule);
38+
explicit PublicSuffixRule(const std::string& rule_text);
3939
PublicSuffixRule(
40-
const std::vector<Label> &labels,
40+
const std::vector<Label>& labels,
4141
bool is_exception = false,
4242
bool is_wildcard = false);
4343

4444
SerializationResult Serialize() const;
4545

46-
bool Equals(const PublicSuffixRule &rule) const;
47-
bool Matches(const Domain &domain) const;
48-
DomainInfo Apply(const Domain &domain) const;
46+
bool Equals(const PublicSuffixRule& rule) const;
47+
bool Matches(const Domain& domain) const;
48+
DomainInfo Apply(const Domain& domain) const;
4949
std::string ToString() const;
5050
std::string DomainString() const;
5151

@@ -68,8 +68,8 @@ class PublicSuffixRule {
6868
bool is_wildcard_ = false;
6969
};
7070

71-
PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer);
72-
std::vector<Label> parse_labels(const std::string &label_text);
71+
PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer);
72+
std::vector<Label> parse_labels(const std::string& label_text);
7373

7474
} // namespace internal
7575
} // namespace brave_etld

‎etld/internal/public_suffix_rule_set.cc‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -118,7 +118,8 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
118118
if (label_result != node->children->end()) {
119119
PublicSuffixRuleMapNode* child_node = node->children->at(current_label);
120120
if (child_node->rule != nullptr) {
121-
if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
121+
if (*match == nullptr ||
122+
child_node->rule->Length() > (*match)->Length()) {
122123
*match = child_node->rule;
123124
}
124125
}
@@ -131,7 +132,8 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
131132
if (wildcard_result != node->children->end()) {
132133
PublicSuffixRuleMapNode* child_node = node->children->at("*");
133134
if (child_node->rule != nullptr) {
134-
if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
135+
if (*match == nullptr ||
136+
child_node->rule->Length() > (*match)->Length()) {
135137
*match = child_node->rule;
136138
}
137139
}
@@ -168,12 +170,12 @@ void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule,
168170
rules_.push_back(new_rule);
169171
return;
170172
}
171-
173+
172174
AddRule(rule, label_index - 1, child_node);
173175
}
174176

175177
PublicSuffixRuleSet rule_set_from_serialization(
176-
const SerializedBuffer &buffer) {
178+
const SerializedBuffer& buffer) {
177179
std::vector<PublicSuffixRule> rules;
178180
for (auto &elm : deserialize_buffer(buffer)) {
179181
rules.push_back(rule_from_serialization(elm));

‎etld/matcher.cc‎

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -18,28 +18,28 @@ using brave_etld::internal::SerializedChildBuffers;
1818
namespace brave_etld {
1919

2020
DomainInfo build_domain_info(const internal::PublicSuffixRule* rule,
21-
const Domain &domain) {
21+
const Domain& domain) {
2222
return rule->Apply(domain);
2323
}
2424

25-
Matcher::Matcher(std::ifstream &rule_file) {
25+
Matcher::Matcher(std::ifstream* rule_file) {
2626
ConsumeParseResult(internal::parse_rule_file(rule_file));
2727
}
2828

29-
Matcher::Matcher(const std::string &rule_text) {
29+
Matcher::Matcher(const std::string& rule_text) {
3030
ConsumeParseResult(internal::parse_rule_text(rule_text));
3131
}
3232

33-
Matcher::Matcher(const PublicSuffixParseResult &rules) {
33+
Matcher::Matcher(const PublicSuffixParseResult& rules) {
3434
ConsumeParseResult(rules);
3535
}
3636

37-
Matcher::Matcher(const Matcher &matcher) :
37+
Matcher::Matcher(const Matcher& matcher) :
3838
rules_(matcher.rules_),
3939
exception_rules_(matcher.exception_rules_) {}
4040

41-
Matcher::Matcher(const internal::PublicSuffixRuleSet &rules,
42-
const internal::PublicSuffixRuleSet &exception_rules) :
41+
Matcher::Matcher(const internal::PublicSuffixRuleSet& rules,
42+
const internal::PublicSuffixRuleSet& exception_rules) :
4343
rules_(rules),
4444
exception_rules_(exception_rules) {}
4545

@@ -70,14 +70,14 @@ SerializationResult Matcher::Serialize() const {
7070
};
7171
}
7272

73-
bool Matcher::Equal(const Matcher &matcher) const {
73+
bool Matcher::Equal(const Matcher& matcher) const {
7474
return (rules_.Equal(matcher.rules_) &&
7575
exception_rules_.Equal(matcher.exception_rules_));
7676
}
7777

7878
// Attempts to implement the algoritms described here:
7979
// https://publicsuffix.org/list/
80-
DomainInfo Matcher::Match(const Domain &domain) const {
80+
DomainInfo Matcher::Match(const Domain& domain) const {
8181
PublicSuffixRuleSetMatchResult except_match = exception_rules_.Match(domain);
8282
if (except_match.found_match) {
8383
return build_domain_info(except_match.rule, domain);
@@ -91,8 +91,7 @@ DomainInfo Matcher::Match(const Domain &domain) const {
9191
return build_domain_info(internal::PublicSuffixRule::root_rule, domain);
9292
}
9393

94-
95-
void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
94+
void Matcher::ConsumeParseResult(const PublicSuffixParseResult& result) {
9695
for (auto &elm : result.Rules()) {
9796
if (elm.IsException()) {
9897
exception_rules_.AddRule(elm);
@@ -102,7 +101,7 @@ void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
102101
}
103102
}
104103

105-
Matcher matcher_from_serialization(const SerializedBuffer &buffer) {
104+
Matcher matcher_from_serialization(const SerializedBuffer& buffer) {
106105
SerializedChildBuffers child_buffers = internal::deserialize_buffer(buffer);
107106
return {
108107
internal::rule_set_from_serialization(child_buffers[0]),

‎etld/matcher.h‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -22,24 +22,24 @@ class Matcher {
2222
public:
2323
Matcher() {}
2424
Matcher(const Matcher &matcher);
25-
explicit Matcher(std::ifstream &rule_file);
26-
explicit Matcher(const std::string &rule_text);
27-
explicit Matcher(const internal::PublicSuffixParseResult &rules);
28-
Matcher(const internal::PublicSuffixRuleSet &rules,
29-
const internal::PublicSuffixRuleSet &exception_rules);
30-
25+
explicit Matcher(std::ifstream* rule_file);
26+
explicit Matcher(const std::string& rule_text);
27+
explicit Matcher(const internal::PublicSuffixParseResult& rules);
28+
Matcher(const internal::PublicSuffixRuleSet& rules,
29+
const internal::PublicSuffixRuleSet& exception_rules);
30+
3131
SerializationResult Serialize() const;
3232

33-
bool Equal(const Matcher &matcher) const;
34-
DomainInfo Match(const Domain &domain) const;
33+
bool Equal(const Matcher& matcher) const;
34+
DomainInfo Match(const Domain& domain) const;
3535

3636
private:
37-
void ConsumeParseResult(const internal::PublicSuffixParseResult &result);
37+
void ConsumeParseResult(const internal::PublicSuffixParseResult& result);
3838
internal::PublicSuffixRuleSet rules_;
3939
internal::PublicSuffixRuleSet exception_rules_;
4040
};
4141

42-
Matcher matcher_from_serialization(const SerializedBuffer &buffer);
42+
Matcher matcher_from_serialization(const SerializedBuffer& buffer);
4343

4444
} // namespace brave_etld
4545

0 commit comments

Comments
 (0)