refactor: VectorWriter without nVersion

MarcoFalke · MarcoFalke · commit fa0ed0794161 · 2023-11-17T14:38:26.000+01:00
The field is unused, so remove it.

This is also required for future commits.
diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
@@ -81,15 +81,15 @@ GCSFilter::GCSFilter(const Params& params, const ElementSet& elements)
     }
     m_F = static_cast<uint64_t>(m_N) * static_cast<uint64_t>(m_params.m_M);
 
-    CVectorWriter stream(GCS_SER_VERSION, m_encoded, 0);
+    VectorWriter stream{m_encoded, 0};
 
     WriteCompactSize(stream, m_N);
 
     if (elements.empty()) {
         return;
     }
 
-    BitStreamWriter<CVectorWriter> bitwriter(stream);
+    BitStreamWriter bitwriter{stream};
 
     uint64_t last_value = 0;
     for (uint64_t value : BuildHashedSet(elements)) {
diff --git a/src/net.cpp b/src/net.cpp
@@ -818,7 +818,7 @@ bool V1Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept
 
     // serialize header
     m_header_to_send.clear();
-    CVectorWriter{INIT_PROTO_VERSION, m_header_to_send, 0, hdr};
+    VectorWriter{m_header_to_send, 0, hdr};
 
     // update state
     m_message_to_send = std::move(msg);
diff --git a/src/netmessagemaker.h b/src/netmessagemaker.h
@@ -12,14 +12,14 @@
 class CNetMsgMaker
 {
 public:
-    explicit CNetMsgMaker(int nVersionIn) : nVersion(nVersionIn){}
+    explicit CNetMsgMaker(int /*unused*/) {}
 
     template <typename... Args>
-    CSerializedNetMsg Make(int nFlags, std::string msg_type, Args&&... args) const
+    CSerializedNetMsg Make(int /*unused*/, std::string msg_type, Args&&... args) const
     {
         CSerializedNetMsg msg;
         msg.m_type = std::move(msg_type);
-        CVectorWriter{nFlags | nVersion, msg.data, 0, std::forward<Args>(args)...};
+        VectorWriter{msg.data, 0, std::forward<Args>(args)...};
         return msg;
     }
 
@@ -28,9 +28,6 @@ class CNetMsgMaker
     {
         return Make(0, std::move(msg_type), std::forward<Args>(args)...);
     }
-
-private:
-    const int nVersion;
 };
 
 #endif // BITCOIN_NETMESSAGEMAKER_H
diff --git a/src/psbt.h b/src/psbt.h
@@ -316,7 +316,7 @@ struct PSBTInput
                 const auto& [leaf_hashes, origin] = leaf_origin;
                 SerializeToVector(s, PSBT_IN_TAP_BIP32_DERIVATION, xonly);
                 std::vector<unsigned char> value;
-                CVectorWriter s_value{s.GetVersion(), value, 0};
+                VectorWriter s_value{value, 0};
                 s_value << leaf_hashes;
                 SerializeKeyOrigin(s_value, origin);
                 s << value;
@@ -757,7 +757,7 @@ struct PSBTOutput
         if (!m_tap_tree.empty()) {
             SerializeToVector(s, PSBT_OUT_TAP_TREE);
             std::vector<unsigned char> value;
-            CVectorWriter s_value{s.GetVersion(), value, 0};
+            VectorWriter s_value{value, 0};
             for (const auto& [depth, leaf_ver, script] : m_tap_tree) {
                 s_value << depth;
                 s_value << leaf_ver;
@@ -771,7 +771,7 @@ struct PSBTOutput
             const auto& [leaf_hashes, origin] = leaf;
             SerializeToVector(s, PSBT_OUT_TAP_BIP32_DERIVATION, xonly);
             std::vector<unsigned char> value;
-            CVectorWriter s_value{s.GetVersion(), value, 0};
+            VectorWriter s_value{value, 0};
             s_value << leaf_hashes;
             SerializeKeyOrigin(s_value, origin);
             s << value;
diff --git a/src/signet.cpp b/src/signet.cpp
@@ -110,7 +110,7 @@ std::optional<SignetTxs> SignetTxs::Create(const CBlock& block, const CScript& c
     uint256 signet_merkle = ComputeModifiedMerkleRoot(modified_cb, block);
 
     std::vector<uint8_t> block_data;
-    CVectorWriter writer{INIT_PROTO_VERSION, block_data, 0};
+    VectorWriter writer{block_data, 0};
     writer << block.nVersion;
     writer << block.hashPrevBlock;
     writer << signet_merkle;
diff --git a/src/streams.h b/src/streams.h
@@ -49,17 +49,15 @@ inline void Xor(Span<std::byte> write, Span<const std::byte> key, size_t key_off
  *
  * The referenced vector will grow as necessary
  */
-class CVectorWriter
+class VectorWriter
 {
- public:
-
+public:
 /*
- * @param[in]  nVersionIn Serialization Version (including any flags)
  * @param[in]  vchDataIn  Referenced byte vector to overwrite/append
  * @param[in]  nPosIn Starting position. Vector index where writes should start. The vector will initially
  *                    grow as necessary to max(nPosIn, vec.size()). So to append, use vec.size().
 */
-    CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn) : nVersion{nVersionIn}, vchData{vchDataIn}, nPos{nPosIn}
+    VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn) : vchData{vchDataIn}, nPos{nPosIn}
     {
         if(nPos > vchData.size())
             vchData.resize(nPos);
@@ -69,7 +67,7 @@ class CVectorWriter
  * @param[in]  args  A list of items to serialize starting at nPosIn.
 */
     template <typename... Args>
-    CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : CVectorWriter{nVersionIn, vchDataIn, nPosIn}
+    VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : VectorWriter{vchDataIn, nPosIn}
     {
         ::SerializeMany(*this, std::forward<Args>(args)...);
     }
@@ -85,19 +83,14 @@ class CVectorWriter
         }
         nPos += src.size();
     }
-    template<typename T>
-    CVectorWriter& operator<<(const T& obj)
+    template <typename T>
+    VectorWriter& operator<<(const T& obj)
     {
         ::Serialize(*this, obj);
         return (*this);
     }
-    int GetVersion() const
-    {
-        return nVersion;
-    }
 
 private:
-    const int nVersion;
     std::vector<unsigned char>& vchData;
     size_t nPos;
 };
diff --git a/src/test/fuzz/golomb_rice.cpp b/src/test/fuzz/golomb_rice.cpp
@@ -51,9 +51,9 @@ FUZZ_TARGET(golomb_rice)
         for (int i = 0; i < n; ++i) {
             elements.insert(ConsumeRandomLengthByteVector(fuzzed_data_provider, 16));
         }
-        CVectorWriter stream{0, golomb_rice_data, 0};
+        VectorWriter stream{golomb_rice_data, 0};
         WriteCompactSize(stream, static_cast<uint32_t>(elements.size()));
-        BitStreamWriter<CVectorWriter> bitwriter(stream);
+        BitStreamWriter bitwriter{stream};
         if (!elements.empty()) {
             uint64_t last_value = 0;
             for (const uint64_t value : BuildHashedSet(elements, static_cast<uint64_t>(elements.size()) * static_cast<uint64_t>(BASIC_FILTER_M))) {
diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
@@ -74,49 +74,49 @@ BOOST_AUTO_TEST_CASE(streams_vector_writer)
     // point should yield the same results, even if the first test grew the
     // vector.
 
-    CVectorWriter{INIT_PROTO_VERSION, vch, 0, a, b};
+    VectorWriter{vch, 0, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{1, 2}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 0, a, b};
+    VectorWriter{vch, 0, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{1, 2}}));
     vch.clear();
 
-    CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
+    VectorWriter{vch, 2, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
+    VectorWriter{vch, 2, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2}}));
     vch.clear();
 
     vch.resize(5, 0);
-    CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
+    VectorWriter{vch, 2, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2, 0}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b};
+    VectorWriter{vch, 2, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2, 0}}));
     vch.clear();
 
     vch.resize(4, 0);
-    CVectorWriter{INIT_PROTO_VERSION, vch, 3, a, b};
+    VectorWriter{vch, 3, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 1, 2}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 3, a, b};
+    VectorWriter{vch, 3, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 1, 2}}));
     vch.clear();
 
     vch.resize(4, 0);
-    CVectorWriter{INIT_PROTO_VERSION, vch, 4, a, b};
+    VectorWriter{vch, 4, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 0, 1, 2}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 4, a, b};
+    VectorWriter{vch, 4, a, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 0, 1, 2}}));
     vch.clear();
 
-    CVectorWriter{INIT_PROTO_VERSION, vch, 0, bytes};
+    VectorWriter{vch, 0, bytes};
     BOOST_CHECK((vch == std::vector<unsigned char>{{3, 4, 5, 6}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 0, bytes};
+    VectorWriter{vch, 0, bytes};
     BOOST_CHECK((vch == std::vector<unsigned char>{{3, 4, 5, 6}}));
     vch.clear();
 
     vch.resize(4, 8);
-    CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, bytes, b};
+    VectorWriter{vch, 2, a, bytes, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{8, 8, 1, 3, 4, 5, 6, 2}}));
-    CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, bytes, b};
+    VectorWriter{vch, 2, a, bytes, b};
     BOOST_CHECK((vch == std::vector<unsigned char>{{8, 8, 1, 3, 4, 5, 6, 2}}));
     vch.clear();
 }
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
@@ -752,7 +752,7 @@ bool malformed_descriptor(std::ios_base::failure e)
 BOOST_FIXTURE_TEST_CASE(wallet_descriptor_test, BasicTestingSetup)
 {
     std::vector<unsigned char> malformed_record;
-    CVectorWriter vw{0, malformed_record, 0};
+    VectorWriter vw{malformed_record, 0};
     vw << std::string("notadescriptor");
     vw << uint64_t{0};
     vw << int32_t{0};

Original file line number	Diff line number	Diff line change
`@@ -81,15 +81,15 @@ GCSFilter::GCSFilter(const Params& params, const ElementSet& elements)`
`81`	`81`	`}`
`82`	`82`	`m_F = static_cast<uint64_t>(m_N) * static_cast<uint64_t>(m_params.m_M);`
`83`	`83`
`84`		`- CVectorWriter stream(GCS_SER_VERSION, m_encoded, 0);`
	`84`	`+ VectorWriter stream{m_encoded, 0};`
`85`	`85`
`86`	`86`	`WriteCompactSize(stream, m_N);`
`87`	`87`
`88`	`88`	`if (elements.empty()) {`
`89`	`89`	`return;`
`90`	`90`	`}`
`91`	`91`
`92`		`- BitStreamWriter<CVectorWriter> bitwriter(stream);`
	`92`	`+ BitStreamWriter bitwriter{stream};`
`93`	`93`
`94`	`94`	`uint64_t last_value = 0;`
`95`	`95`	`for (uint64_t value : BuildHashedSet(elements)) {`
Original file line number	Diff line number	Diff line change
`@@ -12,14 +12,14 @@`
`12`	`12`	`class CNetMsgMaker`
`13`	`13`	`{`
`14`	`14`	`public:`
`15`		`- explicit CNetMsgMaker(int nVersionIn) : nVersion(nVersionIn){}`
	`15`	`+ explicit CNetMsgMaker(int /unused/) {}`
`16`	`16`
`17`	`17`	`template <typename... Args>`
`18`		`- CSerializedNetMsg Make(int nFlags, std::string msg_type, Args&&... args) const`
	`18`	`+ CSerializedNetMsg Make(int /unused/, std::string msg_type, Args&&... args) const`
`19`	`19`	`{`
`20`	`20`	`CSerializedNetMsg msg;`
`21`	`21`	`msg.m_type = std::move(msg_type);`
`22`		`- CVectorWriter{nFlags \| nVersion, msg.data, 0, std::forward<Args>(args)...};`
	`22`	`+ VectorWriter{msg.data, 0, std::forward<Args>(args)...};`
`23`	`23`	`return msg;`
`24`	`24`	`}`
`25`	`25`
`@@ -28,9 +28,6 @@ class CNetMsgMaker`
`28`	`28`	`{`
`29`	`29`	`return Make(0, std::move(msg_type), std::forward<Args>(args)...);`
`30`	`30`	`}`
`31`		`-`
`32`		`-private:`
`33`		`- const int nVersion;`
`34`	`31`	`};`
`35`	`32`
`36`	`33`	`#endif // BITCOIN_NETMESSAGEMAKER_H`
Original file line number	Diff line number	Diff line change
`@@ -49,17 +49,15 @@ inline void Xor(Span<std::byte> write, Span<const std::byte> key, size_t key_off`
`49`	`49`	`*`
`50`	`50`	`* The referenced vector will grow as necessary`
`51`	`51`	`*/`
`52`		`-class CVectorWriter`
	`52`	`+class VectorWriter`
`53`	`53`	`{`
`54`		`- public:`
`55`		`-`
	`54`	`+public:`
`56`	`55`	`/*`
`57`		`- * @param[in] nVersionIn Serialization Version (including any flags)`
`58`	`56`	`* @param[in] vchDataIn Referenced byte vector to overwrite/append`
`59`	`57`	`* @param[in] nPosIn Starting position. Vector index where writes should start. The vector will initially`
`60`	`58`	`* grow as necessary to max(nPosIn, vec.size()). So to append, use vec.size().`
`61`	`59`	`*/`
`62`		`- CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn) : nVersion{nVersionIn}, vchData{vchDataIn}, nPos{nPosIn}`
	`60`	`+ VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn) : vchData{vchDataIn}, nPos{nPosIn}`
`63`	`61`	`{`
`64`	`62`	`if(nPos > vchData.size())`
`65`	`63`	`vchData.resize(nPos);`
`@@ -69,7 +67,7 @@ class CVectorWriter`
`69`	`67`	`* @param[in] args A list of items to serialize starting at nPosIn.`
`70`	`68`	`*/`
`71`	`69`	`template <typename... Args>`
`72`		`- CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : CVectorWriter{nVersionIn, vchDataIn, nPosIn}`
	`70`	`+ VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : VectorWriter{vchDataIn, nPosIn}`
`73`	`71`	`{`
`74`	`72`	`::SerializeMany(*this, std::forward<Args>(args)...);`
`75`	`73`	`}`
`@@ -85,19 +83,14 @@ class CVectorWriter`
`85`	`83`	`}`
`86`	`84`	`nPos += src.size();`
`87`	`85`	`}`
`88`		`- template<typename T>`
`89`		`- CVectorWriter& operator<<(const T& obj)`
	`86`	`+ template <typename T>`
	`87`	`+ VectorWriter& operator<<(const T& obj)`
`90`	`88`	`{`
`91`	`89`	`::Serialize(*this, obj);`
`92`	`90`	`return (*this);`
`93`	`91`	`}`
`94`		`- int GetVersion() const`
`95`		`- {`
`96`		`- return nVersion;`
`97`		`- }`
`98`	`92`
`99`	`93`	`private:`
`100`		`- const int nVersion;`
`101`	`94`	`std::vector<unsigned char>& vchData;`
`102`	`95`	`size_t nPos;`
`103`	`96`	`};`
Original file line number	Diff line number	Diff line change
`@@ -752,7 +752,7 @@ bool malformed_descriptor(std::ios_base::failure e)`
`752`	`752`	`BOOST_FIXTURE_TEST_CASE(wallet_descriptor_test, BasicTestingSetup)`
`753`	`753`	`{`
`754`	`754`	`std::vector<unsigned char> malformed_record;`
`755`		`- CVectorWriter vw{0, malformed_record, 0};`
	`755`	`+ VectorWriter vw{malformed_record, 0};`
`756`	`756`	`vw << std::string("notadescriptor");`
`757`	`757`	`vw << uint64_t{0};`
`758`	`758`	`vw << int32_t{0};`