scripted-diff: Use std::span over Span

-BEGIN VERIFY SCRIPT-

 ren() { sed -i "s!\<$1\>!$2!g" $( git grep -l "$1" -- "./src" ":(exclude)src/span.h" ":(exclude)src/leveldb/db/log_test.cc" ) ; }

 ren Span            std::span
 ren AsBytes         std::as_bytes
 ren AsWritableBytes std::as_writable_bytes

 sed -i 's!SpanPopBack(Span!SpanPopBack(std::span!g' ./src/span.h

-END VERIFY SCRIPT-

Author: MarcoFalke

src/base58.cpp

@@ -86,7 +86,7 @@ static const int8_t mapBase58[256] = {
     return true;
 }
 
-std::string EncodeBase58(Span<const unsigned char> input)
+std::string EncodeBase58(std::span<const unsigned char> input)
 {
     // Skip & count leading zeroes.
     int zeroes = 0;
@@ -134,7 +134,7 @@ bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet, in
     return DecodeBase58(str.c_str(), vchRet, max_ret_len);
 }
 
-std::string EncodeBase58Check(Span<const unsigned char> input)
+std::string EncodeBase58Check(std::span<const unsigned char> input)
 {
     // add 4-byte hash check to the end
     std::vector<unsigned char> vch(input.begin(), input.end());
@@ -151,7 +151,7 @@ std::string EncodeBase58Check(Span<const unsigned char> input)
         return false;
     }
     // re-calculate the checksum, ensure it matches the included 4-byte checksum
-    uint256 hash = Hash(Span{vchRet}.first(vchRet.size() - 4));
+    uint256 hash = Hash(std::span{vchRet}.first(vchRet.size() - 4));
     if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {
         vchRet.clear();
         return false;

src/base58.h

@@ -22,7 +22,7 @@
 /**
  * Encode a byte span as a base58-encoded string
  */
-std::string EncodeBase58(Span<const unsigned char> input);
+std::string EncodeBase58(std::span<const unsigned char> input);
 
 /**
  * Decode a base58-encoded string (str) into a byte vector (vchRet).
@@ -33,7 +33,7 @@ std::string EncodeBase58(Span<const unsigned char> input);
 /**
  * Encode a byte span into a base58-encoded string, including checksum
  */
-std::string EncodeBase58Check(Span<const unsigned char> input);
+std::string EncodeBase58Check(std::span<const unsigned char> input);
 
 /**
  * Decode a base58-encoded string (str) that includes a checksum into a byte

src/bench/load_external.cpp

@@ -46,7 +46,7 @@ static void LoadExternalBlockFile(benchmark::Bench& bench)
     ss << static_cast<uint32_t>(benchmark::data::block413567.size());
     // We can't use the streaming serialization (ss << benchmark::data::block413567)
     // because that first writes a compact size.
-    ss << Span{benchmark::data::block413567};
+    ss << std::span{benchmark::data::block413567};
 
     // Create the test file.
     {

src/bip324.cpp

@@ -70,7 +70,7 @@ void BIP324Cipher::Initialize(const EllSwiftPubKey& their_pubkey, bool initiator
     m_key = CKey();
 }
 
-void BIP324Cipher::Encrypt(Span<const std::byte> contents, Span<const std::byte> aad, bool ignore, Span<std::byte> output) noexcept
+void BIP324Cipher::Encrypt(std::span<const std::byte> contents, std::span<const std::byte> aad, bool ignore, std::span<std::byte> output) noexcept
 {
     assert(output.size() == contents.size() + EXPANSION);
 
@@ -86,7 +86,7 @@ void BIP324Cipher::Encrypt(Span<const std::byte> contents, Span<const std::byte>
     m_send_p_cipher->Encrypt(header, contents, aad, output.subspan(LENGTH_LEN));
 }
 
-uint32_t BIP324Cipher::DecryptLength(Span<const std::byte> input) noexcept
+uint32_t BIP324Cipher::DecryptLength(std::span<const std::byte> input) noexcept
 {
     assert(input.size() == LENGTH_LEN);
 
@@ -97,7 +97,7 @@ uint32_t BIP324Cipher::DecryptLength(Span<const std::byte> input) noexcept
     return uint32_t(buf[0]) + (uint32_t(buf[1]) << 8) + (uint32_t(buf[2]) << 16);
 }
 
-bool BIP324Cipher::Decrypt(Span<const std::byte> input, Span<const std::byte> aad, bool& ignore, Span<std::byte> contents) noexcept
+bool BIP324Cipher::Decrypt(std::span<const std::byte> input, std::span<const std::byte> aad, bool& ignore, std::span<std::byte> contents) noexcept
 {
     assert(input.size() + LENGTH_LEN == contents.size() + EXPANSION);
 

src/bip324.h

@@ -68,29 +68,29 @@ class BIP324Cipher
      *
      * It must hold that output.size() == contents.size() + EXPANSION.
      */
-    void Encrypt(Span<const std::byte> contents, Span<const std::byte> aad, bool ignore, Span<std::byte> output) noexcept;
+    void Encrypt(std::span<const std::byte> contents, std::span<const std::byte> aad, bool ignore, std::span<std::byte> output) noexcept;
 
     /** Decrypt the length of a packet. Only after Initialize().
      *
      * It must hold that input.size() == LENGTH_LEN.
      */
-    unsigned DecryptLength(Span<const std::byte> input) noexcept;
+    unsigned DecryptLength(std::span<const std::byte> input) noexcept;
 
     /** Decrypt a packet. Only after Initialize().
      *
      * It must hold that input.size() + LENGTH_LEN == contents.size() + EXPANSION.
      * Contents.size() must equal the length returned by DecryptLength.
      */
-    bool Decrypt(Span<const std::byte> input, Span<const std::byte> aad, bool& ignore, Span<std::byte> contents) noexcept;
+    bool Decrypt(std::span<const std::byte> input, std::span<const std::byte> aad, bool& ignore, std::span<std::byte> contents) noexcept;
 
     /** Get the Session ID. Only after Initialize(). */
-    Span<const std::byte> GetSessionID() const noexcept { return m_session_id; }
+    std::span<const std::byte> GetSessionID() const noexcept { return m_session_id; }
 
     /** Get the Garbage Terminator to send. Only after Initialize(). */
-    Span<const std::byte> GetSendGarbageTerminator() const noexcept { return m_send_garbage_terminator; }
+    std::span<const std::byte> GetSendGarbageTerminator() const noexcept { return m_send_garbage_terminator; }
 
     /** Get the expected Garbage Terminator to receive. Only after Initialize(). */
-    Span<const std::byte> GetReceiveGarbageTerminator() const noexcept { return m_recv_garbage_terminator; }
+    std::span<const std::byte> GetReceiveGarbageTerminator() const noexcept { return m_recv_garbage_terminator; }
 };
 
 #endif // BITCOIN_BIP324_H

src/cluster_linearize.h

@@ -75,7 +75,7 @@ class DepGraph
      *
      * @param depgraph   The original DepGraph that is being remapped.
      *
-     * @param mapping    A Span such that mapping[i] gives the position in the new DepGraph
+     * @param mapping    A std::span such that mapping[i] gives the position in the new DepGraph
      *                   for position i in the old depgraph. Its size must be equal to
      *                   depgraph.PositionRange(). The value of mapping[i] is ignored if
      *                   position i is a hole in depgraph (i.e., if !depgraph.Positions()[i]).
@@ -86,7 +86,7 @@ class DepGraph
      *
      * Complexity: O(N^2) where N=depgraph.TxCount().
      */
-    DepGraph(const DepGraph<SetType>& depgraph, Span<const ClusterIndex> mapping, ClusterIndex pos_range) noexcept : entries(pos_range)
+    DepGraph(const DepGraph<SetType>& depgraph, std::span<const ClusterIndex> mapping, ClusterIndex pos_range) noexcept : entries(pos_range)
     {
         Assume(mapping.size() == depgraph.PositionRange());
         Assume((pos_range == 0) == (depgraph.TxCount() == 0));
@@ -371,7 +371,7 @@ struct SetInfo
 
 /** Compute the feerates of the chunks of linearization. */
 template<typename SetType>
-std::vector<FeeFrac> ChunkLinearization(const DepGraph<SetType>& depgraph, Span<const ClusterIndex> linearization) noexcept
+std::vector<FeeFrac> ChunkLinearization(const DepGraph<SetType>& depgraph, std::span<const ClusterIndex> linearization) noexcept
 {
     std::vector<FeeFrac> ret;
     for (ClusterIndex i : linearization) {
@@ -396,7 +396,7 @@ class LinearizationChunking
     const DepGraph<SetType>& m_depgraph;
 
     /** The linearization we started from, possibly with removed prefix stripped. */
-    Span<const ClusterIndex> m_linearization;
+    std::span<const ClusterIndex> m_linearization;
 
     /** Chunk sets and their feerates, of what remains of the linearization. */
     std::vector<SetInfo<SetType>> m_chunks;
@@ -437,7 +437,7 @@ class LinearizationChunking
 
 public:
     /** Initialize a LinearizationSubset object for a given length of linearization. */
-    explicit LinearizationChunking(const DepGraph<SetType>& depgraph LIFETIMEBOUND, Span<const ClusterIndex> lin LIFETIMEBOUND) noexcept :
+    explicit LinearizationChunking(const DepGraph<SetType>& depgraph LIFETIMEBOUND, std::span<const ClusterIndex> lin LIFETIMEBOUND) noexcept :
         m_depgraph(depgraph), m_linearization(lin)
     {
         // Mark everything in lin as todo still.
@@ -1016,7 +1016,7 @@ class SearchCandidateFinder
  * Complexity: possibly O(N * min(max_iterations + N, sqrt(2^N))) where N=depgraph.TxCount().
  */
 template<typename SetType>
-std::pair<std::vector<ClusterIndex>, bool> Linearize(const DepGraph<SetType>& depgraph, uint64_t max_iterations, uint64_t rng_seed, Span<const ClusterIndex> old_linearization = {}) noexcept
+std::pair<std::vector<ClusterIndex>, bool> Linearize(const DepGraph<SetType>& depgraph, uint64_t max_iterations, uint64_t rng_seed, std::span<const ClusterIndex> old_linearization = {}) noexcept
 {
     Assume(old_linearization.empty() || old_linearization.size() == depgraph.TxCount());
     if (depgraph.TxCount() == 0) return {{}, true};
@@ -1110,7 +1110,7 @@ std::pair<std::vector<ClusterIndex>, bool> Linearize(const DepGraph<SetType>& de
  *   postlinearize" process.
  */
 template<typename SetType>
-void PostLinearize(const DepGraph<SetType>& depgraph, Span<ClusterIndex> linearization)
+void PostLinearize(const DepGraph<SetType>& depgraph, std::span<ClusterIndex> linearization)
 {
     // This algorithm performs a number of passes (currently 2); the even ones operate from back to
     // front, the odd ones from front to back. Each results in an equal-or-better linearization
@@ -1299,7 +1299,7 @@ void PostLinearize(const DepGraph<SetType>& depgraph, Span<ClusterIndex> lineari
  * Complexity: O(N^2) where N=depgraph.TxCount(); O(N) if both inputs are identical.
  */
 template<typename SetType>
-std::vector<ClusterIndex> MergeLinearizations(const DepGraph<SetType>& depgraph, Span<const ClusterIndex> lin1, Span<const ClusterIndex> lin2)
+std::vector<ClusterIndex> MergeLinearizations(const DepGraph<SetType>& depgraph, std::span<const ClusterIndex> lin1, std::span<const ClusterIndex> lin2)
 {
     Assume(lin1.size() == depgraph.TxCount());
     Assume(lin2.size() == depgraph.TxCount());

src/common/bloom.cpp

@@ -40,13 +40,13 @@ CBloomFilter::CBloomFilter(const unsigned int nElements, const double nFPRate, c
 {
 }
 
-inline unsigned int CBloomFilter::Hash(unsigned int nHashNum, Span<const unsigned char> vDataToHash) const
+inline unsigned int CBloomFilter::Hash(unsigned int nHashNum, std::span<const unsigned char> vDataToHash) const
 {
     // 0xFBA4C795 chosen as it guarantees a reasonable bit difference between nHashNum values.
     return MurmurHash3(nHashNum * 0xFBA4C795 + nTweak, vDataToHash) % (vData.size() * 8);
 }
 
-void CBloomFilter::insert(Span<const unsigned char> vKey)
+void CBloomFilter::insert(std::span<const unsigned char> vKey)
 {
     if (vData.empty()) // Avoid divide-by-zero (CVE-2013-5700)
         return;
@@ -65,7 +65,7 @@ void CBloomFilter::insert(const COutPoint& outpoint)
     insert(MakeUCharSpan(stream));
 }
 
-bool CBloomFilter::contains(Span<const unsigned char> vKey) const
+bool CBloomFilter::contains(std::span<const unsigned char> vKey) const
 {
     if (vData.empty()) // Avoid divide-by-zero (CVE-2013-5700)
         return true;
@@ -187,12 +187,12 @@ CRollingBloomFilter::CRollingBloomFilter(const unsigned int nElements, const dou
 }
 
 /* Similar to CBloomFilter::Hash */
-static inline uint32_t RollingBloomHash(unsigned int nHashNum, uint32_t nTweak, Span<const unsigned char> vDataToHash)
+static inline uint32_t RollingBloomHash(unsigned int nHashNum, uint32_t nTweak, std::span<const unsigned char> vDataToHash)
 {
     return MurmurHash3(nHashNum * 0xFBA4C795 + nTweak, vDataToHash);
 }
 
-void CRollingBloomFilter::insert(Span<const unsigned char> vKey)
+void CRollingBloomFilter::insert(std::span<const unsigned char> vKey)
 {
     if (nEntriesThisGeneration == nEntriesPerGeneration) {
         nEntriesThisGeneration = 0;
@@ -223,7 +223,7 @@ void CRollingBloomFilter::insert(Span<const unsigned char> vKey)
     }
 }
 
-bool CRollingBloomFilter::contains(Span<const unsigned char> vKey) const
+bool CRollingBloomFilter::contains(std::span<const unsigned char> vKey) const
 {
     for (int n = 0; n < nHashFuncs; n++) {
         uint32_t h = RollingBloomHash(n, nTweak, vKey);

src/common/bloom.h

@@ -49,7 +49,7 @@ class CBloomFilter
     unsigned int nTweak;
     unsigned char nFlags;
 
-    unsigned int Hash(unsigned int nHashNum, Span<const unsigned char> vDataToHash) const;
+    unsigned int Hash(unsigned int nHashNum, std::span<const unsigned char> vDataToHash) const;
 
 public:
     /**
@@ -66,10 +66,10 @@ class CBloomFilter
 
     SERIALIZE_METHODS(CBloomFilter, obj) { READWRITE(obj.vData, obj.nHashFuncs, obj.nTweak, obj.nFlags); }
 
-    void insert(Span<const unsigned char> vKey);
+    void insert(std::span<const unsigned char> vKey);
     void insert(const COutPoint& outpoint);
 
-    bool contains(Span<const unsigned char> vKey) const;
+    bool contains(std::span<const unsigned char> vKey) const;
     bool contains(const COutPoint& outpoint) const;
 
     //! True if the size is <= MAX_BLOOM_FILTER_SIZE and the number of hash functions is <= MAX_HASH_FUNCS
@@ -110,8 +110,8 @@ class CRollingBloomFilter
 public:
     CRollingBloomFilter(const unsigned int nElements, const double nFPRate);
 
-    void insert(Span<const unsigned char> vKey);
-    bool contains(Span<const unsigned char> vKey) const;
+    void insert(std::span<const unsigned char> vKey);
+    bool contains(std::span<const unsigned char> vKey) const;
 
     void reset();
 

src/common/pcp.cpp

@@ -179,7 +179,7 @@ std::string PCPResultString(uint8_t result_code)
 }
 
 //! Wrap address in IPv6 according to RFC6887. wrapped_addr needs to be able to store 16 bytes.
-[[nodiscard]] bool PCPWrapAddress(Span<uint8_t> wrapped_addr, const CNetAddr &addr)
+[[nodiscard]] bool PCPWrapAddress(std::span<uint8_t> wrapped_addr, const CNetAddr &addr)
 {
     Assume(wrapped_addr.size() == ADDR_IPV6_SIZE);
     if (addr.IsIPv4()) {
@@ -200,7 +200,7 @@ std::string PCPResultString(uint8_t result_code)
 }
 
 //! Unwrap PCP-encoded address according to RFC6887.
-CNetAddr PCPUnwrapAddress(Span<const uint8_t> wrapped_addr)
+CNetAddr PCPUnwrapAddress(std::span<const uint8_t> wrapped_addr)
 {
     Assume(wrapped_addr.size() == ADDR_IPV6_SIZE);
     if (util::HasPrefix(wrapped_addr, IPV4_IN_IPV6_PREFIX)) {
@@ -215,9 +215,9 @@ CNetAddr PCPUnwrapAddress(Span<const uint8_t> wrapped_addr)
 }
 
 //! PCP or NAT-PMP send-receive loop.
-std::optional<std::vector<uint8_t>> PCPSendRecv(Sock &sock, const std::string &protocol, Span<const uint8_t> request, int num_tries,
+std::optional<std::vector<uint8_t>> PCPSendRecv(Sock &sock, const std::string &protocol, std::span<const uint8_t> request, int num_tries,
         std::chrono::milliseconds timeout_per_try,
-        std::function<bool(Span<const uint8_t>)> check_packet)
+        std::function<bool(std::span<const uint8_t>)> check_packet)
 {
     using namespace std::chrono;
     // UDP is a potentially lossy protocol, so we try to send again a few times.
@@ -254,9 +254,9 @@ std::optional<std::vector<uint8_t>> PCPSendRecv(Sock &sock, const std::string &p
                 LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "%s: Could not receive response: %s\n", protocol, NetworkErrorString(WSAGetLastError()));
                 return std::nullopt; // Network-level error, probably no use retrying.
             }
-            LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "%s: Received response of %d bytes: %s\n", protocol, recvsz, HexStr(Span(response, recvsz)));
+            LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "%s: Received response of %d bytes: %s\n", protocol, recvsz, HexStr(std::span(response, recvsz)));
 
-            if (check_packet(Span<uint8_t>(response, recvsz))) {
+            if (check_packet(std::span<uint8_t>(response, recvsz))) {
                 got_response = true; // Got expected response, break from receive loop as well as from retry loop.
                 break;
             }
@@ -309,7 +309,7 @@ std::variant<MappingResult, MappingError> NATPMPRequestPortMap(const CNetAddr &g
     request[NATPMP_HDR_OP_OFS] = NATPMP_REQUEST | NATPMP_OP_GETEXTERNAL;
 
     auto recv_res = PCPSendRecv(*sock, "natpmp", request, num_tries, timeout_per_try,
-        [&](const Span<const uint8_t> response) -> bool {
+        [&](const std::span<const uint8_t> response) -> bool {
             if (response.size() < NATPMP_GETEXTERNAL_RESPONSE_SIZE) {
                 LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "natpmp: Response too small\n");
                 return false; // Wasn't response to what we expected, try receiving next packet.
@@ -346,7 +346,7 @@ std::variant<MappingResult, MappingError> NATPMPRequestPortMap(const CNetAddr &g
     WriteBE32(request.data() + NATPMP_MAP_REQUEST_LIFETIME_OFS, lifetime);
 
     recv_res = PCPSendRecv(*sock, "natpmp", request, num_tries, timeout_per_try,
-        [&](const Span<const uint8_t> response) -> bool {
+        [&](const std::span<const uint8_t> response) -> bool {
             if (response.size() < NATPMP_MAP_RESPONSE_SIZE) {
                 LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "natpmp: Response too small\n");
                 return false; // Wasn't response to what we expected, try receiving next packet.
@@ -438,7 +438,7 @@ std::variant<MappingResult, MappingError> PCPRequestPortMap(const PCPMappingNonc
     request[ofs + PCP_HDR_VERSION_OFS] = PCP_VERSION;
     request[ofs + PCP_HDR_OP_OFS] = PCP_REQUEST | PCP_OP_MAP;
     WriteBE32(request.data() + ofs + PCP_HDR_LIFETIME_OFS, lifetime);
-    if (!PCPWrapAddress(Span(request).subspan(ofs + PCP_REQUEST_HDR_IP_OFS, ADDR_IPV6_SIZE), internal)) return MappingError::NETWORK_ERROR;
+    if (!PCPWrapAddress(std::span(request).subspan(ofs + PCP_REQUEST_HDR_IP_OFS, ADDR_IPV6_SIZE), internal)) return MappingError::NETWORK_ERROR;
 
     ofs += PCP_HDR_SIZE;
 
@@ -449,15 +449,15 @@ std::variant<MappingResult, MappingError> PCPRequestPortMap(const PCPMappingNonc
     request[ofs + PCP_MAP_PROTOCOL_OFS] = PCP_PROTOCOL_TCP;
     WriteBE16(request.data() + ofs + PCP_MAP_INTERNAL_PORT_OFS, port);
     WriteBE16(request.data() + ofs + PCP_MAP_EXTERNAL_PORT_OFS, port);
-    if (!PCPWrapAddress(Span(request).subspan(ofs + PCP_MAP_EXTERNAL_IP_OFS, ADDR_IPV6_SIZE), bind)) return MappingError::NETWORK_ERROR;
+    if (!PCPWrapAddress(std::span(request).subspan(ofs + PCP_MAP_EXTERNAL_IP_OFS, ADDR_IPV6_SIZE), bind)) return MappingError::NETWORK_ERROR;
 
     ofs += PCP_MAP_SIZE;
     Assume(ofs == request.size());
 
     // Receive loop.
     bool is_natpmp = false;
     auto recv_res = PCPSendRecv(*sock, "pcp", request, num_tries, timeout_per_try,
-        [&](const Span<const uint8_t> response) -> bool {
+        [&](const std::span<const uint8_t> response) -> bool {
             // Unsupported version according to RFC6887 appendix A and RFC6886 section 3.5, can fall back to NAT-PMP.
             if (response.size() == NATPMP_RESPONSE_HDR_SIZE && response[PCP_HDR_VERSION_OFS] == NATPMP_VERSION && response[PCP_RESPONSE_HDR_RESULT_OFS] == NATPMP_RESULT_UNSUPP_VERSION) {
                 is_natpmp = true;

src/compressor.h

@@ -65,12 +65,12 @@ struct ScriptCompression
     void Ser(Stream &s, const CScript& script) {
         CompressedScript compr;
         if (CompressScript(script, compr)) {
-            s << Span{compr};
+            s << std::span{compr};
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
-        s << Span{script};
+        s << std::span{script};
     }
 
     template<typename Stream>
@@ -79,7 +79,7 @@ struct ScriptCompression
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             CompressedScript vch(GetSpecialScriptSize(nSize), 0x00);
-            s >> Span{vch};
+            s >> std::span{vch};
             DecompressScript(script, nSize, vch);
             return;
         }
@@ -90,7 +90,7 @@ struct ScriptCompression
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> Span{script};
+            s >> std::span{script};
         }
     }
 };