github-actions[bot] commented on code in PR #38277:
URL: https://github.com/apache/doris/pull/38277#discussion_r1701518832
##########
be/src/vec/exec/format/parquet/parquet_common.cpp:
##########
@@ -162,4 +162,336 @@
void ColumnSelectVector::skip(size_t num_values) {
_filter_map_index += num_values;
}
+
+ParsedVersion::ParsedVersion(std::string application,
std::optional<std::string> version,
+ std::optional<std::string> app_build_hash)
+ : _application(std::move(application)),
+ _version(std::move(version)),
+ _app_build_hash(std::move(app_build_hash)) {}
+
+bool ParsedVersion::operator==(const ParsedVersion& other) const {
+ return _application == other._application && _version == other._version &&
+ _app_build_hash == other._app_build_hash;
+}
+
+bool ParsedVersion::operator!=(const ParsedVersion& other) const {
+ return !(*this == other);
+}
+
+size_t ParsedVersion::hash() const {
+ std::hash<std::string> hasher;
+ return hasher(_application) ^ (_version ? hasher(*_version) : 0) ^
+ (_app_build_hash ? hasher(*_app_build_hash) : 0);
+}
+
+std::string ParsedVersion::to_string() const {
+ return "ParsedVersion(application=" + _application +
+ ", semver=" + (_version ? *_version : "null") +
+ ", app_build_hash=" + (_app_build_hash ? *_app_build_hash : "null")
+ ")";
+}
+
+Status VersionParser::parse(const std::string& created_by,
+ std::unique_ptr<ParsedVersion>* parsed_version) {
+ static const std::string FORMAT =
+
"(.*?)\\s+version\\s*(?:([^(]*?)\\s*(?:\\(\\s*build\\s*([^)]*?)\\s*\\))?)?";
+ static const std::regex PATTERN(FORMAT);
+
+ std::smatch matcher;
+ if (!std::regex_match(created_by, matcher, PATTERN)) {
+ return Status::InternalError(fmt::format("Could not parse created_by:
{}, using format: {}",
+ created_by, FORMAT));
+ }
+
+ std::string application = matcher[1].str();
+ if (application.empty()) {
+ return Status::InternalError("application cannot be null or empty");
+ }
+ std::optional<std::string> semver =
+ matcher[2].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[2].str());
+ std::optional<std::string> app_build_hash =
+ matcher[3].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[3].str());
+ *parsed_version = std::make_unique<ParsedVersion>(application, semver,
app_build_hash);
+ return Status::OK();
+}
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(false),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+
+#ifdef BE_TEST
+SemanticVersion::SemanticVersion(int major, int minor, int patch, bool
has_unknown)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(has_unknown),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+#endif
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch,
+ std::optional<std::string> unknown,
std::optional<std::string> pre,
+ std::optional<std::string> build_info)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(unknown.has_value() && !unknown.value().empty()),
+ _unknown(std::move(unknown)),
+ _pre(pre.has_value() ?
std::optional<Prerelease>(Prerelease(std::move(pre.value())))
+ : std::nullopt),
+ _build_info(std::move(build_info)) {}
+
+Status SemanticVersion::parse(const std::string& version,
+ std::unique_ptr<SemanticVersion>*
semantic_version) {
+ static const std::regex
pattern(R"(^(\d+)\.(\d+)\.(\d+)([^-+]*)?(?:-([^+]*))?(?:\+(.*))?$)");
+ std::smatch match;
+
+ if (!std::regex_match(version, match, pattern)) {
+ return Status::InternalError(version + " does not match format");
+ }
+
+ int major = std::stoi(match[1].str());
+ int minor = std::stoi(match[2].str());
+ int patch = std::stoi(match[3].str());
+ std::optional<std::string> unknown =
+ match[4].str().empty() ? std::nullopt :
std::optional<std::string>(match[4].str());
+ std::optional<std::string> prerelease =
+ match[5].str().empty() ? std::nullopt :
std::optional<std::string>(match[5].str());
+ std::optional<std::string> build_info =
+ match[6].str().empty() ? std::nullopt :
std::optional<std::string>(match[6].str());
+ if (major < 0 || minor < 0 || patch < 0) {
+ return Status::InternalError("major({}), minor({}), and patch({}) must
all be >= 0", major,
+ minor, patch);
+ }
+ *semantic_version =
+ std::make_unique<SemanticVersion>(major, minor, patch, unknown,
prerelease, build_info);
+ return Status::OK();
+}
+
+int SemanticVersion::compare_to(const SemanticVersion& other) const {
+ if (int cmp = _compare_integers(_major, other._major); cmp != 0) return
cmp;
+ if (int cmp = _compare_integers(_minor, other._minor); cmp != 0) return
cmp;
+ if (int cmp = _compare_integers(_patch, other._patch); cmp != 0) return
cmp;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
if (int cmp = _compare_integers(_patch, other._patch); cmp != 0) {
return cmp;
}
```
##########
be/src/vec/exec/format/parquet/parquet_common.h:
##########
@@ -156,4 +158,132 @@ class ColumnSelectVector {
size_t _num_filtered;
size_t _read_index;
};
-} // namespace doris::vectorized
\ No newline at end of file
+
+enum class ColumnOrderName { UNDEFINED, TYPE_DEFINED_ORDER };
+
+enum class SortOrder { SIGNED, UNSIGNED, UNKNOWN };
+
+class ParsedVersion {
+public:
+ ParsedVersion(std::string application, std::optional<std::string> version,
+ std::optional<std::string> app_build_hash);
+
+ const std::string& application() const { return _application; }
+
+ const std::optional<std::string>& version() const { return _version; }
+
+ const std::optional<std::string>& app_build_hash() const { return
_app_build_hash; }
+
+ bool operator==(const ParsedVersion& other) const;
+
+ bool operator!=(const ParsedVersion& other) const;
+
+ size_t hash() const;
+
+ std::string to_string() const;
+
+private:
+ std::string _application;
+ std::optional<std::string> _version;
+ std::optional<std::string> _app_build_hash;
+};
+
+class VersionParser {
+public:
+ static Status parse(const std::string& created_by,
+ std::unique_ptr<ParsedVersion>* parsed_version);
+};
+
+class SemanticVersion {
+public:
+ SemanticVersion(int major, int minor, int patch);
+
+#ifdef BE_TEST
+ SemanticVersion(int major, int minor, int patch, bool has_unknown);
+#endif
+
+ SemanticVersion(int major, int minor, int patch,
std::optional<std::string> unknown,
+ std::optional<std::string> pre, std::optional<std::string>
build_info);
+
+ static Status parse(const std::string& version,
+ std::unique_ptr<SemanticVersion>* semantic_version);
+
+ int compare_to(const SemanticVersion& other) const;
+
+ bool operator==(const SemanticVersion& other) const;
+
+ bool operator!=(const SemanticVersion& other) const;
+
+ std::string to_string() const;
+
+private:
+ class NumberOrString {
+ public:
+ explicit NumberOrString(const std::string& value_string);
+
+ NumberOrString(const NumberOrString& other);
+
+ int compare_to(const NumberOrString& that) const;
+ std::string to_string() const;
+
+ bool operator<(const NumberOrString& that) const;
+ bool operator==(const NumberOrString& that) const;
+ bool operator!=(const NumberOrString& that) const;
+ bool operator>(const NumberOrString& that) const;
+ bool operator<=(const NumberOrString& that) const;
+ bool operator>=(const NumberOrString& that) const;
+
+ private:
+ std::string _original;
+ bool _is_numeric;
+ int _number;
+ };
+
+ class Prerelease {
+ public:
+ explicit Prerelease(std::string original);
+
+ int compare_to(const Prerelease& that) const;
+ std::string to_string() const;
+
+ bool operator<(const Prerelease& that) const;
+ bool operator==(const Prerelease& that) const;
+ bool operator!=(const Prerelease& that) const;
+ bool operator>(const Prerelease& that) const;
+ bool operator<=(const Prerelease& that) const;
+ bool operator>=(const Prerelease& that) const;
+
+ const std::string& original() const { return _original; }
+
+ private:
+ static std::vector<std::string> _split(const std::string& s, const
std::regex& delimiter);
+
+ std::string _original;
+ std::vector<NumberOrString> _identifiers;
+ };
+
+private:
Review Comment:
warning: redundant access specifier has the same accessibility as the
previous access specifier [readability-redundant-access-specifiers]
```suggestion
```
<details>
<summary>Additional context</summary>
**be/src/vec/exec/format/parquet/parquet_common.h:218:** previously declared
here
```cpp
private:
^
```
</details>
##########
be/src/vec/exec/format/parquet/parquet_common.cpp:
##########
@@ -162,4 +162,336 @@ bool ColumnSelectVector::can_filter_all(size_t
remaining_num_values) {
void ColumnSelectVector::skip(size_t num_values) {
_filter_map_index += num_values;
}
+
+ParsedVersion::ParsedVersion(std::string application,
std::optional<std::string> version,
+ std::optional<std::string> app_build_hash)
+ : _application(std::move(application)),
+ _version(std::move(version)),
+ _app_build_hash(std::move(app_build_hash)) {}
+
+bool ParsedVersion::operator==(const ParsedVersion& other) const {
+ return _application == other._application && _version == other._version &&
+ _app_build_hash == other._app_build_hash;
+}
+
+bool ParsedVersion::operator!=(const ParsedVersion& other) const {
+ return !(*this == other);
+}
+
+size_t ParsedVersion::hash() const {
+ std::hash<std::string> hasher;
+ return hasher(_application) ^ (_version ? hasher(*_version) : 0) ^
+ (_app_build_hash ? hasher(*_app_build_hash) : 0);
+}
+
+std::string ParsedVersion::to_string() const {
+ return "ParsedVersion(application=" + _application +
+ ", semver=" + (_version ? *_version : "null") +
+ ", app_build_hash=" + (_app_build_hash ? *_app_build_hash : "null")
+ ")";
+}
+
+Status VersionParser::parse(const std::string& created_by,
+ std::unique_ptr<ParsedVersion>* parsed_version) {
+ static const std::string FORMAT =
+
"(.*?)\\s+version\\s*(?:([^(]*?)\\s*(?:\\(\\s*build\\s*([^)]*?)\\s*\\))?)?";
+ static const std::regex PATTERN(FORMAT);
+
+ std::smatch matcher;
+ if (!std::regex_match(created_by, matcher, PATTERN)) {
+ return Status::InternalError(fmt::format("Could not parse created_by:
{}, using format: {}",
+ created_by, FORMAT));
+ }
+
+ std::string application = matcher[1].str();
+ if (application.empty()) {
+ return Status::InternalError("application cannot be null or empty");
+ }
+ std::optional<std::string> semver =
+ matcher[2].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[2].str());
+ std::optional<std::string> app_build_hash =
+ matcher[3].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[3].str());
+ *parsed_version = std::make_unique<ParsedVersion>(application, semver,
app_build_hash);
+ return Status::OK();
+}
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(false),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+
+#ifdef BE_TEST
+SemanticVersion::SemanticVersion(int major, int minor, int patch, bool
has_unknown)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(has_unknown),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+#endif
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch,
+ std::optional<std::string> unknown,
std::optional<std::string> pre,
+ std::optional<std::string> build_info)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(unknown.has_value() && !unknown.value().empty()),
+ _unknown(std::move(unknown)),
+ _pre(pre.has_value() ?
std::optional<Prerelease>(Prerelease(std::move(pre.value())))
+ : std::nullopt),
+ _build_info(std::move(build_info)) {}
+
+Status SemanticVersion::parse(const std::string& version,
+ std::unique_ptr<SemanticVersion>*
semantic_version) {
+ static const std::regex
pattern(R"(^(\d+)\.(\d+)\.(\d+)([^-+]*)?(?:-([^+]*))?(?:\+(.*))?$)");
+ std::smatch match;
+
+ if (!std::regex_match(version, match, pattern)) {
+ return Status::InternalError(version + " does not match format");
+ }
+
+ int major = std::stoi(match[1].str());
+ int minor = std::stoi(match[2].str());
+ int patch = std::stoi(match[3].str());
+ std::optional<std::string> unknown =
+ match[4].str().empty() ? std::nullopt :
std::optional<std::string>(match[4].str());
+ std::optional<std::string> prerelease =
+ match[5].str().empty() ? std::nullopt :
std::optional<std::string>(match[5].str());
+ std::optional<std::string> build_info =
+ match[6].str().empty() ? std::nullopt :
std::optional<std::string>(match[6].str());
+ if (major < 0 || minor < 0 || patch < 0) {
+ return Status::InternalError("major({}), minor({}), and patch({}) must
all be >= 0", major,
+ minor, patch);
+ }
+ *semantic_version =
+ std::make_unique<SemanticVersion>(major, minor, patch, unknown,
prerelease, build_info);
+ return Status::OK();
+}
+
+int SemanticVersion::compare_to(const SemanticVersion& other) const {
+ if (int cmp = _compare_integers(_major, other._major); cmp != 0) return
cmp;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
if (int cmp = _compare_integers(_major, other._major); cmp != 0) {
return cmp;
}
```
##########
be/src/vec/exec/format/parquet/parquet_common.cpp:
##########
@@ -162,4 +162,336 @@
void ColumnSelectVector::skip(size_t num_values) {
_filter_map_index += num_values;
}
+
+ParsedVersion::ParsedVersion(std::string application,
std::optional<std::string> version,
+ std::optional<std::string> app_build_hash)
+ : _application(std::move(application)),
+ _version(std::move(version)),
+ _app_build_hash(std::move(app_build_hash)) {}
+
+bool ParsedVersion::operator==(const ParsedVersion& other) const {
+ return _application == other._application && _version == other._version &&
+ _app_build_hash == other._app_build_hash;
+}
+
+bool ParsedVersion::operator!=(const ParsedVersion& other) const {
+ return !(*this == other);
+}
+
+size_t ParsedVersion::hash() const {
+ std::hash<std::string> hasher;
+ return hasher(_application) ^ (_version ? hasher(*_version) : 0) ^
+ (_app_build_hash ? hasher(*_app_build_hash) : 0);
+}
+
+std::string ParsedVersion::to_string() const {
+ return "ParsedVersion(application=" + _application +
+ ", semver=" + (_version ? *_version : "null") +
+ ", app_build_hash=" + (_app_build_hash ? *_app_build_hash : "null")
+ ")";
+}
+
+Status VersionParser::parse(const std::string& created_by,
+ std::unique_ptr<ParsedVersion>* parsed_version) {
+ static const std::string FORMAT =
+
"(.*?)\\s+version\\s*(?:([^(]*?)\\s*(?:\\(\\s*build\\s*([^)]*?)\\s*\\))?)?";
+ static const std::regex PATTERN(FORMAT);
+
+ std::smatch matcher;
+ if (!std::regex_match(created_by, matcher, PATTERN)) {
+ return Status::InternalError(fmt::format("Could not parse created_by:
{}, using format: {}",
+ created_by, FORMAT));
+ }
+
+ std::string application = matcher[1].str();
+ if (application.empty()) {
+ return Status::InternalError("application cannot be null or empty");
+ }
+ std::optional<std::string> semver =
+ matcher[2].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[2].str());
+ std::optional<std::string> app_build_hash =
+ matcher[3].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[3].str());
+ *parsed_version = std::make_unique<ParsedVersion>(application, semver,
app_build_hash);
+ return Status::OK();
+}
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(false),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+
+#ifdef BE_TEST
+SemanticVersion::SemanticVersion(int major, int minor, int patch, bool
has_unknown)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(has_unknown),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+#endif
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch,
+ std::optional<std::string> unknown,
std::optional<std::string> pre,
+ std::optional<std::string> build_info)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(unknown.has_value() && !unknown.value().empty()),
+ _unknown(std::move(unknown)),
+ _pre(pre.has_value() ?
std::optional<Prerelease>(Prerelease(std::move(pre.value())))
+ : std::nullopt),
+ _build_info(std::move(build_info)) {}
+
+Status SemanticVersion::parse(const std::string& version,
+ std::unique_ptr<SemanticVersion>*
semantic_version) {
+ static const std::regex
pattern(R"(^(\d+)\.(\d+)\.(\d+)([^-+]*)?(?:-([^+]*))?(?:\+(.*))?$)");
+ std::smatch match;
+
+ if (!std::regex_match(version, match, pattern)) {
+ return Status::InternalError(version + " does not match format");
+ }
+
+ int major = std::stoi(match[1].str());
+ int minor = std::stoi(match[2].str());
+ int patch = std::stoi(match[3].str());
+ std::optional<std::string> unknown =
+ match[4].str().empty() ? std::nullopt :
std::optional<std::string>(match[4].str());
+ std::optional<std::string> prerelease =
+ match[5].str().empty() ? std::nullopt :
std::optional<std::string>(match[5].str());
+ std::optional<std::string> build_info =
+ match[6].str().empty() ? std::nullopt :
std::optional<std::string>(match[6].str());
+ if (major < 0 || minor < 0 || patch < 0) {
+ return Status::InternalError("major({}), minor({}), and patch({}) must
all be >= 0", major,
+ minor, patch);
+ }
+ *semantic_version =
+ std::make_unique<SemanticVersion>(major, minor, patch, unknown,
prerelease, build_info);
+ return Status::OK();
+}
+
+int SemanticVersion::compare_to(const SemanticVersion& other) const {
+ if (int cmp = _compare_integers(_major, other._major); cmp != 0) return
cmp;
+ if (int cmp = _compare_integers(_minor, other._minor); cmp != 0) return
cmp;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
if (int cmp = _compare_integers(_minor, other._minor); cmp != 0) {
return cmp;
}
```
##########
be/src/vec/exec/format/parquet/parquet_common.cpp:
##########
@@ -162,4 +162,336 @@
void ColumnSelectVector::skip(size_t num_values) {
_filter_map_index += num_values;
}
+
+ParsedVersion::ParsedVersion(std::string application,
std::optional<std::string> version,
+ std::optional<std::string> app_build_hash)
+ : _application(std::move(application)),
+ _version(std::move(version)),
+ _app_build_hash(std::move(app_build_hash)) {}
+
+bool ParsedVersion::operator==(const ParsedVersion& other) const {
+ return _application == other._application && _version == other._version &&
+ _app_build_hash == other._app_build_hash;
+}
+
+bool ParsedVersion::operator!=(const ParsedVersion& other) const {
+ return !(*this == other);
+}
+
+size_t ParsedVersion::hash() const {
+ std::hash<std::string> hasher;
+ return hasher(_application) ^ (_version ? hasher(*_version) : 0) ^
+ (_app_build_hash ? hasher(*_app_build_hash) : 0);
+}
+
+std::string ParsedVersion::to_string() const {
+ return "ParsedVersion(application=" + _application +
+ ", semver=" + (_version ? *_version : "null") +
+ ", app_build_hash=" + (_app_build_hash ? *_app_build_hash : "null")
+ ")";
+}
+
+Status VersionParser::parse(const std::string& created_by,
+ std::unique_ptr<ParsedVersion>* parsed_version) {
+ static const std::string FORMAT =
+
"(.*?)\\s+version\\s*(?:([^(]*?)\\s*(?:\\(\\s*build\\s*([^)]*?)\\s*\\))?)?";
+ static const std::regex PATTERN(FORMAT);
+
+ std::smatch matcher;
+ if (!std::regex_match(created_by, matcher, PATTERN)) {
+ return Status::InternalError(fmt::format("Could not parse created_by:
{}, using format: {}",
+ created_by, FORMAT));
+ }
+
+ std::string application = matcher[1].str();
+ if (application.empty()) {
+ return Status::InternalError("application cannot be null or empty");
+ }
+ std::optional<std::string> semver =
+ matcher[2].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[2].str());
+ std::optional<std::string> app_build_hash =
+ matcher[3].str().empty() ? std::nullopt :
std::optional<std::string>(matcher[3].str());
+ *parsed_version = std::make_unique<ParsedVersion>(application, semver,
app_build_hash);
+ return Status::OK();
+}
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(false),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+
+#ifdef BE_TEST
+SemanticVersion::SemanticVersion(int major, int minor, int patch, bool
has_unknown)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(has_unknown),
+ _unknown(std::nullopt),
+ _pre(std::nullopt),
+ _build_info(std::nullopt) {}
+#endif
+
+SemanticVersion::SemanticVersion(int major, int minor, int patch,
+ std::optional<std::string> unknown,
std::optional<std::string> pre,
+ std::optional<std::string> build_info)
+ : _major(major),
+ _minor(minor),
+ _patch(patch),
+ _prerelease(unknown.has_value() && !unknown.value().empty()),
+ _unknown(std::move(unknown)),
+ _pre(pre.has_value() ?
std::optional<Prerelease>(Prerelease(std::move(pre.value())))
+ : std::nullopt),
+ _build_info(std::move(build_info)) {}
+
+Status SemanticVersion::parse(const std::string& version,
+ std::unique_ptr<SemanticVersion>*
semantic_version) {
+ static const std::regex
pattern(R"(^(\d+)\.(\d+)\.(\d+)([^-+]*)?(?:-([^+]*))?(?:\+(.*))?$)");
+ std::smatch match;
+
+ if (!std::regex_match(version, match, pattern)) {
+ return Status::InternalError(version + " does not match format");
+ }
+
+ int major = std::stoi(match[1].str());
+ int minor = std::stoi(match[2].str());
+ int patch = std::stoi(match[3].str());
+ std::optional<std::string> unknown =
+ match[4].str().empty() ? std::nullopt :
std::optional<std::string>(match[4].str());
+ std::optional<std::string> prerelease =
+ match[5].str().empty() ? std::nullopt :
std::optional<std::string>(match[5].str());
+ std::optional<std::string> build_info =
+ match[6].str().empty() ? std::nullopt :
std::optional<std::string>(match[6].str());
+ if (major < 0 || minor < 0 || patch < 0) {
+ return Status::InternalError("major({}), minor({}), and patch({}) must
all be >= 0", major,
+ minor, patch);
+ }
+ *semantic_version =
+ std::make_unique<SemanticVersion>(major, minor, patch, unknown,
prerelease, build_info);
+ return Status::OK();
+}
+
+int SemanticVersion::compare_to(const SemanticVersion& other) const {
+ if (int cmp = _compare_integers(_major, other._major); cmp != 0) return
cmp;
+ if (int cmp = _compare_integers(_minor, other._minor); cmp != 0) return
cmp;
+ if (int cmp = _compare_integers(_patch, other._patch); cmp != 0) return
cmp;
+ if (int cmp = _compare_booleans(other._prerelease, _prerelease); cmp != 0)
return cmp;
Review Comment:
warning: statement should be inside braces
[readability-braces-around-statements]
```suggestion
if (int cmp = _compare_booleans(other._prerelease, _prerelease); cmp !=
0) { return cmp;
}
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
