Merge remote-tracking branch 'upstream/develop' into neverfeature

* upstream/develop:
  Rectify the import paths of boost/iterator: (XRPLF#4293)
  Allow port numbers be be specified with a colon: (XRPLF#4328)
  Use <=> operator for base_uint, Issue, and Book: (XRPLF#4411)
  Reporting Mode: Do not attempt to acquire missing data from peer network (XRPLF#4458)

src/ripple/app/ledger/Ledger.cpp

@@ -266,7 +266,7 @@ Ledger::Ledger(
     {
         info_.hash = calculateLedgerHash(info_);
         if (acquire && !config.reporting())
-            family.missingNode(info_.hash, info_.seq);
+            family.missingNodeAcquireByHash(info_.hash, info_.seq);
     }
 }
 

src/ripple/app/tx/impl/details/NFTokenUtils.cpp

@@ -146,19 +146,22 @@ getPageForToken(
                 return nullptr;
             else
             {
-                // This would be an ideal place for the spaceship operator...
-                int const relation = compare(id & nft::pageMask, cmp);
+                auto const relation{(id & nft::pageMask) <=> cmp};
                 if (relation == 0)
+                {
                     // If the passed in id belongs exactly on this (full) page
                     // this account simply cannot store the NFT.
                     return nullptr;
+                }
 
-                else if (relation > 0)
+                if (relation > 0)
+                {
                     // We need to leave the entire contents of this page in
                     // narr so carr stays empty.  The new NFT will be
                     // inserted in carr.  This keeps the NFTs that must be
                     // together all on their own page.
                     splitIter = narr.end();
+                }
 
                 // If neither of those conditions apply then put all of
                 // narr into carr and produce an empty narr where the new NFT
@@ -228,7 +231,7 @@ compareTokens(uint256 const& a, uint256 const& b)
     // 96-bits are identical we still need a fully deterministic sort.
     // So we sort on the low 96-bits first. If those are equal we sort on
     // the whole thing.
-    if (auto const lowBitsCmp = compare(a & nft::pageMask, b & nft::pageMask);
+    if (auto const lowBitsCmp{(a & nft::pageMask) <=> (b & nft::pageMask)};
         lowBitsCmp != 0)
         return lowBitsCmp < 0;
 

src/ripple/basics/base_uint.h

@@ -33,6 +33,7 @@
 #include <ripple/beast/utility/Zero.h>
 #include <boost/endian/conversion.hpp>
 #include <boost/functional/hash.hpp>
+#include <algorithm>
 #include <array>
 #include <cstring>
 #include <functional>
@@ -549,103 +550,66 @@ using uint160 = base_uint<160>;
 using uint256 = base_uint<256>;
 
 template <std::size_t Bits, class Tag>
-inline int
-compare(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
+[[nodiscard]] inline constexpr std::strong_ordering
+operator<=>(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
 {
-    auto ret = std::mismatch(a.cbegin(), a.cend(), b.cbegin());
-
-    if (ret.first == a.cend())
-        return 0;
+    // This comparison might seem wrong on a casual inspection because it
+    // compares data internally stored as std::uint32_t byte-by-byte. But
+    // note that the underlying data is stored in big endian, even if the
+    // plaform is little endian. This makes the comparison correct.
+    //
+    // FIXME: use std::lexicographical_compare_three_way once support is
+    //        added to MacOS.
 
-    // a > b
-    if (*ret.first > *ret.second)
-        return 1;
+    auto const ret = std::mismatch(lhs.cbegin(), lhs.cend(), rhs.cbegin());
 
-    // a < b
-    return -1;
-}
-
-template <std::size_t Bits, class Tag>
-inline bool
-operator<(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
-{
-    return compare(a, b) < 0;
-}
+    // a == b
+    if (ret.first == lhs.cend())
+        return std::strong_ordering::equivalent;
 
-template <std::size_t Bits, class Tag>
-inline bool
-operator<=(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
-{
-    return compare(a, b) <= 0;
+    return (*ret.first > *ret.second) ? std::strong_ordering::greater
+                                      : std::strong_ordering::less;
 }
 
-template <std::size_t Bits, class Tag>
-inline bool
-operator>(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
+template <std::size_t Bits, typename Tag>
+[[nodiscard]] inline constexpr bool
+operator==(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
 {
-    return compare(a, b) > 0;
-}
-
-template <std::size_t Bits, class Tag>
-inline bool
-operator>=(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
-{
-    return compare(a, b) >= 0;
-}
-
-template <std::size_t Bits, class Tag>
-inline bool
-operator==(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
-{
-    return compare(a, b) == 0;
-}
-
-template <std::size_t Bits, class Tag>
-inline bool
-operator!=(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
-{
-    return compare(a, b) != 0;
+    return (lhs <=> rhs) == 0;
 }
 
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
-inline bool
+inline constexpr bool
 operator==(base_uint<Bits, Tag> const& a, std::uint64_t b)
 {
     return a == base_uint<Bits, Tag>(b);
 }
 
-template <std::size_t Bits, class Tag>
-inline bool
-operator!=(base_uint<Bits, Tag> const& a, std::uint64_t b)
-{
-    return !(a == b);
-}
-
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
-inline const base_uint<Bits, Tag>
+inline constexpr base_uint<Bits, Tag>
 operator^(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
 {
     return base_uint<Bits, Tag>(a) ^= b;
 }
 
 template <std::size_t Bits, class Tag>
-inline const base_uint<Bits, Tag>
+inline constexpr base_uint<Bits, Tag>
 operator&(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
 {
     return base_uint<Bits, Tag>(a) &= b;
 }
 
 template <std::size_t Bits, class Tag>
-inline const base_uint<Bits, Tag>
+inline constexpr base_uint<Bits, Tag>
 operator|(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
 {
     return base_uint<Bits, Tag>(a) |= b;
 }
 
 template <std::size_t Bits, class Tag>
-inline const base_uint<Bits, Tag>
+inline constexpr base_uint<Bits, Tag>
 operator+(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
 {
     return base_uint<Bits, Tag>(a) += b;

src/ripple/core/impl/Config.cpp

@@ -37,6 +37,7 @@
 #include <cstdlib>
 #include <iostream>
 #include <iterator>
+#include <regex>
 #include <thread>
 
 #if BOOST_OS_WINDOWS
@@ -468,6 +469,28 @@ Config::loadFromString(std::string const& fileContents)
     if (auto s = getIniFileSection(secConfig, SECTION_SNTP))
         SNTP_SERVERS = *s;
 
+    // if the user has specified ip:port then replace : with a space.
+    {
+        auto replaceColons = [](std::vector<std::string>& strVec) {
+            const static std::regex e(":([0-9]+)$");
+            for (auto& line : strVec)
+            {
+                // skip anything that might be an ipv6 address
+                if (std::count(line.begin(), line.end(), ':') != 1)
+                    continue;
+
+                std::string result = std::regex_replace(line, e, " $1");
+                // sanity check the result of the replace, should be same length
+                // as input
+                if (result.size() == line.size())
+                    line = result;
+            }
+        };
+
+        replaceColons(IPS_FIXED);
+        replaceColons(IPS);
+    }
+
     {
         std::string dbPath;
         if (getSingleSection(secConfig, "database_path", dbPath, j_))

src/ripple/net/impl/RPCCall.cpp

@@ -482,17 +482,31 @@ class RPCParser
         return jvRequest;
     }
 
-    // connect <ip> [port]
+    // connect <ip[:port]> [port]
     Json::Value
     parseConnect(Json::Value const& jvParams)
     {
         Json::Value jvRequest(Json::objectValue);
-
-        jvRequest[jss::ip] = jvParams[0u].asString();
-
+        std::string ip = jvParams[0u].asString();
         if (jvParams.size() == 2)
+        {
+            jvRequest[jss::ip] = ip;
             jvRequest[jss::port] = jvParams[1u].asUInt();
+            return jvRequest;
+        }
+
+        // handle case where there is one argument of the form ip:port
+        if (std::count(ip.begin(), ip.end(), ':') == 1)
+        {
+            std::size_t colon = ip.find_last_of(":");
+            jvRequest[jss::ip] = std::string{ip, 0, colon};
+            jvRequest[jss::port] =
+                Json::Value{std::string{ip, colon + 1}}.asUInt();
+            return jvRequest;
+        }
 
+        // default case, no port
+        jvRequest[jss::ip] = ip;
         return jvRequest;
     }
 

src/ripple/overlay/impl/ProtocolVersion.cpp

@@ -20,7 +20,7 @@
 #include <ripple/beast/core/LexicalCast.h>
 #include <ripple/beast/rfc2616.h>
 #include <ripple/overlay/impl/ProtocolVersion.h>
-#include <boost/function_output_iterator.hpp>
+#include <boost/iterator/function_output_iterator.hpp>
 #include <boost/regex.hpp>
 #include <algorithm>
 #include <functional>

src/ripple/protocol/Book.h

@@ -65,28 +65,24 @@ hash_append(Hasher& h, Book const& b)
 Book
 reversed(Book const& book);
 
-/** Ordered comparison. */
-int
-compare(Book const& lhs, Book const& rhs);
-
 /** Equality comparison. */
 /** @{ */
-bool
-operator==(Book const& lhs, Book const& rhs);
-bool
-operator!=(Book const& lhs, Book const& rhs);
+[[nodiscard]] inline constexpr bool
+operator==(Book const& lhs, Book const& rhs)
+{
+    return (lhs.in == rhs.in) && (lhs.out == rhs.out);
+}
 /** @} */
 
 /** Strict weak ordering. */
 /** @{ */
-bool
-operator<(Book const& lhs, Book const& rhs);
-bool
-operator>(Book const& lhs, Book const& rhs);
-bool
-operator>=(Book const& lhs, Book const& rhs);
-bool
-operator<=(Book const& lhs, Book const& rhs);
+[[nodiscard]] inline constexpr std::weak_ordering
+operator<=>(Book const& lhs, Book const& rhs)
+{
+    if (auto const c{lhs.in <=> rhs.in}; c != 0)
+        return c;
+    return lhs.out <=> rhs.out;
+}
 /** @} */
 
 }  // namespace ripple

src/ripple/protocol/Issue.h

@@ -63,31 +63,29 @@ hash_append(Hasher& h, Issue const& r)
     hash_append(h, r.currency, r.account);
 }
 
-/** Ordered comparison.
-    The assets are ordered first by currency and then by account,
-    if the currency is not XRP.
-*/
-int
-compare(Issue const& lhs, Issue const& rhs);
-
 /** Equality comparison. */
 /** @{ */
-bool
-operator==(Issue const& lhs, Issue const& rhs);
-bool
-operator!=(Issue const& lhs, Issue const& rhs);
+[[nodiscard]] inline constexpr bool
+operator==(Issue const& lhs, Issue const& rhs)
+{
+    return (lhs.currency == rhs.currency) &&
+        (isXRP(lhs.currency) || lhs.account == rhs.account);
+}
 /** @} */
 
 /** Strict weak ordering. */
 /** @{ */
-bool
-operator<(Issue const& lhs, Issue const& rhs);
-bool
-operator>(Issue const& lhs, Issue const& rhs);
-bool
-operator>=(Issue const& lhs, Issue const& rhs);
-bool
-operator<=(Issue const& lhs, Issue const& rhs);
+[[nodiscard]] inline constexpr std::weak_ordering
+operator<=>(Issue const& lhs, Issue const& rhs)
+{
+    if (auto const c{lhs.currency <=> rhs.currency}; c != 0)
+        return c;
+
+    if (isXRP(lhs.currency))
+        return std::weak_ordering::equivalent;
+
+    return (lhs.account <=> rhs.account);
+}
 /** @} */
 
 //------------------------------------------------------------------------------