More use of auto instead of explicit std::strong_ordering.

Author: gknowles

libs/basic/charbuf.h

@@ -45,15 +45,11 @@ class CharBufBase {
     CharBufBase & operator+=(std::string_view str) { return append(str); }
     CharBufBase & operator+=(const CharBufBase & src) { return append(src); }
 
-    std::strong_ordering operator<=>(const CharBufBase & right) const {
-        return compare(right);
-    }
-    std::strong_ordering operator<=>(std::string_view right) const {
-        return compare(right);
-    }
-    std::strong_ordering operator<=>(const char right[]) const {
+    auto operator<=>(const CharBufBase & right) const {
         return compare(right);
     }
+    auto operator<=>(std::string_view right) const { return compare(right); }
+    auto operator<=>(const char right[]) const { return compare(right); }
 
     bool operator==(const CharBufBase & right) const {
         return compare(right) == 0;

libs/basic/intset.h

@@ -153,7 +153,7 @@ class IntegralSet {
     // compare
     std::strong_ordering compare(const IntegralSet & other) const;
     std::strong_ordering operator<=>(const IntegralSet & other) const;
-    bool operator==(const IntegralSet & right) const;
+    bool operator==(const IntegralSet & other) const;
 
     // search
     value_type front() const;
@@ -181,9 +181,9 @@ class IntegralSet {
 private:
     friend std::ostream & operator<<(
         std::ostream & os,
-        const IntegralSet & right
+        const IntegralSet & val
     ) {
-        if (auto v = right.ranges().begin()) {
+        if (auto v = val.ranges().begin()) {
             for (;;) {
                 os << v->first;
                 if (auto len = v->second - v->first) {

libs/basic/types.h

@@ -65,8 +65,7 @@ struct VersionInfo {
     unsigned patch;
     unsigned build;
 
-    bool operator==(const VersionInfo &) const = default;
-    std::strong_ordering operator<=>(const VersionInfo &) const = default;
+    auto operator<=>(const VersionInfo &) const = default;
     explicit operator bool() const { return *this != VersionInfo{}; }
 };
 

libs/net/address.cpp

@@ -265,3 +265,8 @@ size_t std::hash<SubnetAddr>::operator()(const SubnetAddr & val) const {
     hashCombine(&out, std::hash<int>{}(val.prefixLen));
     return out;
 }
+
+//===========================================================================
+SubnetAddr::operator bool() const {
+    return prefixLen || addr;
+}

libs/net/address.h

@@ -85,7 +85,7 @@ struct HostAddr {
     // Sets to "::FFFF.a.b.c.d" format
     uint32_t ipv4(uint32_t addr);
 
-    std::strong_ordering operator<=>(const HostAddr & right) const = default;
+    auto operator<=>(const HostAddr & right) const = default;
     explicit operator bool() const;
 
 private:
@@ -97,7 +97,7 @@ struct SockAddr {
     HostAddr addr;
     unsigned port = {};
 
-    std::strong_ordering operator<=>(const SockAddr & right) const = default;
+    auto operator<=>(const SockAddr & right) const = default;
     explicit operator bool() const;
 
 private:
@@ -109,6 +109,9 @@ struct SubnetAddr {
     HostAddr addr;
     unsigned prefixLen = {};
 
+    auto operator<=>(const SubnetAddr & right) const = default;
+    explicit operator bool() const;
+
 private:
     friend std::ostream & operator<<(
         std::ostream & os,

libs/net/httproute.cpp

@@ -588,7 +588,7 @@ const unordered_map<string_view, MimeType> s_mimeTypeMap = []() {
 }();
 
 //===========================================================================
-strong_ordering MimeType::operator<=>(const MimeType & other) const {
+auto MimeType::operator<=>(const MimeType & other) const {
     return fileExt <=> other.fileExt;
 }
 

libs/net/httproute.h

@@ -339,7 +339,7 @@ struct MimeType {
     std::string_view type;
     std::string_view charSet;
 
-    std::strong_ordering operator<=>(const MimeType & other) const;
+    auto operator<=>(const MimeType & other) const;
     bool operator==(const MimeType & other) const = default;
 };
 MimeType mimeTypeDefault(std::string_view path);

tools/cmtupd/cmtupd.cpp

@@ -54,12 +54,8 @@ struct Action {
 
     strong_ordering operator<=>(const Action & other) const {
         // Lowest type first.
-        auto rc = reportType <=> other.reportType;
-        if (rc == 0) {
-            // Best (lowest) priority first.
-            rc = reportPriority <=> other.reportPriority;
-        }
-        return rc;
+        return tie(reportType, reportPriority) <=>
+            tie(other.reportType, other.reportPriority);
     }
 };
 const TokenTable::Token s_actionTypes[] = {
@@ -95,7 +91,7 @@ struct Config {
 struct Count {
     const Action * act;
     unsigned count = {};
-    strong_ordering operator<=>(const Count & other) const {
+    auto operator<=>(const Count & other) const {
         return *act <=> *other.act;
     }
 };

tools/pargen/intern.h

@@ -75,12 +75,7 @@ struct Element {
     std::string eventName; // only present if different from name
 
     auto operator<=>(const Element & right) const {
-        if (auto cmp = name.compare(right.name)) {
-            return cmp < 0
-                ? std::strong_ordering::less
-                : std::strong_ordering::greater;
-        }
-        return std::strong_ordering::equal;
+        return name <=> right.name;
     }
 
 private: