Merge #9305: Refactor: Removed begin/end_ptr functions.

laanwj · laanwj · commit 5233aefa3f52 · 2016-12-13T12:21:18.000+01:00
8c1dbc5 Refactor: Removed begin/end_ptr functions. (Karl-Johan Alm)
diff --git a/src/bench/crypto_hash.cpp b/src/bench/crypto_hash.cpp
@@ -22,31 +22,31 @@ static void RIPEMD160(benchmark::State& state)
     uint8_t hash[CRIPEMD160::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
     while (state.KeepRunning())
-        CRIPEMD160().Write(begin_ptr(in), in.size()).Finalize(hash);
+        CRIPEMD160().Write(in.data(), in.size()).Finalize(hash);
 }
 
 static void SHA1(benchmark::State& state)
 {
     uint8_t hash[CSHA1::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
     while (state.KeepRunning())
-        CSHA1().Write(begin_ptr(in), in.size()).Finalize(hash);
+        CSHA1().Write(in.data(), in.size()).Finalize(hash);
 }
 
 static void SHA256(benchmark::State& state)
 {
     uint8_t hash[CSHA256::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
     while (state.KeepRunning())
-        CSHA256().Write(begin_ptr(in), in.size()).Finalize(hash);
+        CSHA256().Write(in.data(), in.size()).Finalize(hash);
 }
 
 static void SHA256_32b(benchmark::State& state)
 {
     std::vector<uint8_t> in(32,0);
     while (state.KeepRunning()) {
         for (int i = 0; i < 1000000; i++) {
-            CSHA256().Write(begin_ptr(in), in.size()).Finalize(&in[0]);
+            CSHA256().Write(in.data(), in.size()).Finalize(&in[0]);
         }
     }
 }
@@ -56,7 +56,7 @@ static void SHA512(benchmark::State& state)
     uint8_t hash[CSHA512::OUTPUT_SIZE];
     std::vector<uint8_t> in(BUFFER_SIZE,0);
     while (state.KeepRunning())
-        CSHA512().Write(begin_ptr(in), in.size()).Finalize(hash);
+        CSHA512().Write(in.data(), in.size()).Finalize(hash);
 }
 
 static void SipHash_32b(benchmark::State& state)
diff --git a/src/bench/verify_script.cpp b/src/bench/verify_script.cpp
@@ -91,7 +91,7 @@ static void VerifyScriptBench(benchmark::State& state)
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << txSpend;
         int csuccess = bitcoinconsensus_verify_script_with_amount(
-            begin_ptr(txCredit.vout[0].scriptPubKey),
+            txCredit.vout[0].scriptPubKey.data(),
             txCredit.vout[0].scriptPubKey.size(),
             txCredit.vout[0].nValue,
             (const unsigned char*)&stream[0], stream.size(), 0, flags, nullptr);
diff --git a/src/netbase.cpp b/src/netbase.cpp
@@ -292,7 +292,7 @@ static bool Socks5(const std::string& strDest, int port, const ProxyCredentials
         vSocks5Init.push_back(0x01); // # METHODS
         vSocks5Init.push_back(0x00); // X'00' NO AUTHENTICATION REQUIRED
     }
-    ssize_t ret = send(hSocket, (const char*)begin_ptr(vSocks5Init), vSocks5Init.size(), MSG_NOSIGNAL);
+    ssize_t ret = send(hSocket, (const char*)vSocks5Init.data(), vSocks5Init.size(), MSG_NOSIGNAL);
     if (ret != (ssize_t)vSocks5Init.size()) {
         CloseSocket(hSocket);
         return error("Error sending to proxy");
@@ -317,7 +317,7 @@ static bool Socks5(const std::string& strDest, int port, const ProxyCredentials
         vAuth.insert(vAuth.end(), auth->username.begin(), auth->username.end());
         vAuth.push_back(auth->password.size());
         vAuth.insert(vAuth.end(), auth->password.begin(), auth->password.end());
-        ret = send(hSocket, (const char*)begin_ptr(vAuth), vAuth.size(), MSG_NOSIGNAL);
+        ret = send(hSocket, (const char*)vAuth.data(), vAuth.size(), MSG_NOSIGNAL);
         if (ret != (ssize_t)vAuth.size()) {
             CloseSocket(hSocket);
             return error("Error sending authentication to proxy");
@@ -347,7 +347,7 @@ static bool Socks5(const std::string& strDest, int port, const ProxyCredentials
     vSocks5.insert(vSocks5.end(), strDest.begin(), strDest.end());
     vSocks5.push_back((port >> 8) & 0xFF);
     vSocks5.push_back((port >> 0) & 0xFF);
-    ret = send(hSocket, (const char*)begin_ptr(vSocks5), vSocks5.size(), MSG_NOSIGNAL);
+    ret = send(hSocket, (const char*)vSocks5.data(), vSocks5.size(), MSG_NOSIGNAL);
     if (ret != (ssize_t)vSocks5.size()) {
         CloseSocket(hSocket);
         return error("Error sending to proxy");
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
@@ -117,7 +117,7 @@ static std::string DummyAddress(const CChainParams &params)
     std::vector<unsigned char> sourcedata = params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
     sourcedata.insert(sourcedata.end(), dummydata, dummydata + sizeof(dummydata));
     for(int i=0; i<256; ++i) { // Try every trailing byte
-        std::string s = EncodeBase58(begin_ptr(sourcedata), end_ptr(sourcedata));
+        std::string s = EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size());
         if (!CBitcoinAddress(s).IsValid())
             return s;
         sourcedata[sourcedata.size()-1] += 1;
diff --git a/src/random.cpp b/src/random.cpp
@@ -11,7 +11,6 @@
 #include "compat.h" // for Windows API
 #include <wincrypt.h>
 #endif
-#include "serialize.h"        // for begin_ptr(vec)
 #include "util.h"             // for LogPrint()
 #include "utilstrencodings.h" // for GetTime()
 
@@ -72,15 +71,15 @@ static void RandAddSeedPerfmon()
     const size_t nMaxSize = 10000000; // Bail out at more than 10MB of performance data
     while (true) {
         nSize = vData.size();
-        ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, begin_ptr(vData), &nSize);
+        ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, vData.data(), &nSize);
         if (ret != ERROR_MORE_DATA || vData.size() >= nMaxSize)
             break;
         vData.resize(std::max((vData.size() * 3) / 2, nMaxSize)); // Grow size of buffer exponentially
     }
     RegCloseKey(HKEY_PERFORMANCE_DATA);
     if (ret == ERROR_SUCCESS) {
-        RAND_add(begin_ptr(vData), nSize, nSize / 100.0);
-        memory_cleanse(begin_ptr(vData), nSize);
+        RAND_add(vData.data(), nSize, nSize / 100.0);
+        memory_cleanse(vData.data(), nSize);
         LogPrint("rand", "%s: %lu bytes\n", __func__, nSize);
     } else {
         static bool warned = false; // Warn only once
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
@@ -856,15 +856,15 @@ bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, un
                     valtype& vch = stacktop(-1);
                     valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32);
                     if (opcode == OP_RIPEMD160)
-                        CRIPEMD160().Write(begin_ptr(vch), vch.size()).Finalize(begin_ptr(vchHash));
+                        CRIPEMD160().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                     else if (opcode == OP_SHA1)
-                        CSHA1().Write(begin_ptr(vch), vch.size()).Finalize(begin_ptr(vchHash));
+                        CSHA1().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                     else if (opcode == OP_SHA256)
-                        CSHA256().Write(begin_ptr(vch), vch.size()).Finalize(begin_ptr(vchHash));
+                        CSHA256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                     else if (opcode == OP_HASH160)
-                        CHash160().Write(begin_ptr(vch), vch.size()).Finalize(begin_ptr(vchHash));
+                        CHash160().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                     else if (opcode == OP_HASH256)
-                        CHash256().Write(begin_ptr(vch), vch.size()).Finalize(begin_ptr(vchHash));
+                        CHash256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
                     popstack(stack);
                     stack.push_back(vchHash);
                 }
diff --git a/src/serialize.h b/src/serialize.h
@@ -59,34 +59,6 @@ inline T* NCONST_PTR(const T* val)
     return const_cast<T*>(val);
 }
 
-/**
- * Important: Do not use the following functions in new code, but use v.data()
- * and v.data() + v.size() respectively directly. They were once introduced to
- * have a compatible, safe way to get the begin and end pointer of a vector.
- * However with C++11 the language has built-in functionality for this and it's
- * more readable to just use that.
- */
-template <typename V>
-inline typename V::value_type* begin_ptr(V& v)
-{
-    return v.data();
-}
-template <typename V>
-inline const typename V::value_type* begin_ptr(const V& v)
-{
-    return v.data();
-}
-template <typename V>
-inline typename V::value_type* end_ptr(V& v)
-{
-    return v.data() + v.size();
-}
-template <typename V>
-inline const typename V::value_type* end_ptr(const V& v)
-{
-    return v.data() + v.size();
-}
-
 /*
  * Lowest-level serialization and conversion.
  * @note Sizes of these types are verified in the tests
@@ -390,14 +362,14 @@ class CFlatData
     template <class T, class TAl>
     explicit CFlatData(std::vector<T,TAl> &v)
     {
-        pbegin = (char*)begin_ptr(v);
-        pend = (char*)end_ptr(v);
+        pbegin = (char*)v.data();
+        pend = (char*)(v.data() + v.size());
     }
     template <unsigned int N, typename T, typename S, typename D>
     explicit CFlatData(prevector<N, T, S, D> &v)
     {
-        pbegin = (char*)begin_ptr(v);
-        pend = (char*)end_ptr(v);
+        pbegin = (char*)v.data();
+        pend = (char*)(v.data() + v.size());
     }
     char* begin() { return pbegin; }
     const char* begin() const { return pbegin; }
diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp
@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
         std::vector<unsigned char> sourcedata = ParseHex(test[0].get_str());
         std::string base58string = test[1].get_str();
         BOOST_CHECK_MESSAGE(
-                    EncodeBase58(begin_ptr(sourcedata), end_ptr(sourcedata)) == base58string,
+                    EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size()) == base58string,
                     strTest);
     }
 }
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
@@ -176,10 +176,10 @@ void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScript
     int libconsensus_flags = flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
     if (libconsensus_flags == flags) {
         if (flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS) {
-            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(begin_ptr(scriptPubKey), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);
         } else {
-            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(begin_ptr(scriptPubKey), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);
-            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(begin_ptr(scriptPubKey), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect,message);
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect,message);
         }
     }
 #endif
diff --git a/src/torcontrol.cpp b/src/torcontrol.cpp
@@ -501,10 +501,10 @@ static std::vector<uint8_t> ComputeResponse(const std::string &key, const std::v
 {
     CHMAC_SHA256 computeHash((const uint8_t*)key.data(), key.size());
     std::vector<uint8_t> computedHash(CHMAC_SHA256::OUTPUT_SIZE, 0);
-    computeHash.Write(begin_ptr(cookie), cookie.size());
-    computeHash.Write(begin_ptr(clientNonce), clientNonce.size());
-    computeHash.Write(begin_ptr(serverNonce), serverNonce.size());
-    computeHash.Finalize(begin_ptr(computedHash));
+    computeHash.Write(cookie.data(), cookie.size());
+    computeHash.Write(clientNonce.data(), clientNonce.size());
+    computeHash.Write(serverNonce.data(), serverNonce.size());
+    computeHash.Finalize(computedHash.data());
     return computedHash;
 }
 
diff --git a/src/util.cpp b/src/util.cpp
@@ -704,13 +704,13 @@ void ShrinkDebugFile()
         // Restart the file with some of the end
         std::vector <char> vch(200000,0);
         fseek(file, -((long)vch.size()), SEEK_END);
-        int nBytes = fread(begin_ptr(vch), 1, vch.size(), file);
+        int nBytes = fread(vch.data(), 1, vch.size(), file);
         fclose(file);
 
         file = fopen(pathLog.string().c_str(), "w");
         if (file)
         {
-            fwrite(begin_ptr(vch), 1, nBytes, file);
+            fwrite(vch.data(), 1, nBytes, file);
             fclose(file);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -22,31 +22,31 @@ static void RIPEMD160(benchmark::State& state)`
`22`	`22`	`uint8_t hash[CRIPEMD160::OUTPUT_SIZE];`
`23`	`23`	`std::vector<uint8_t> in(BUFFER_SIZE,0);`
`24`	`24`	`while (state.KeepRunning())`
`25`		`- CRIPEMD160().Write(begin_ptr(in), in.size()).Finalize(hash);`
	`25`	`+ CRIPEMD160().Write(in.data(), in.size()).Finalize(hash);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`static void SHA1(benchmark::State& state)`
`29`	`29`	`{`
`30`	`30`	`uint8_t hash[CSHA1::OUTPUT_SIZE];`
`31`	`31`	`std::vector<uint8_t> in(BUFFER_SIZE,0);`
`32`	`32`	`while (state.KeepRunning())`
`33`		`- CSHA1().Write(begin_ptr(in), in.size()).Finalize(hash);`
	`33`	`+ CSHA1().Write(in.data(), in.size()).Finalize(hash);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`static void SHA256(benchmark::State& state)`
`37`	`37`	`{`
`38`	`38`	`uint8_t hash[CSHA256::OUTPUT_SIZE];`
`39`	`39`	`std::vector<uint8_t> in(BUFFER_SIZE,0);`
`40`	`40`	`while (state.KeepRunning())`
`41`		`- CSHA256().Write(begin_ptr(in), in.size()).Finalize(hash);`
	`41`	`+ CSHA256().Write(in.data(), in.size()).Finalize(hash);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`static void SHA256_32b(benchmark::State& state)`
`45`	`45`	`{`
`46`	`46`	`std::vector<uint8_t> in(32,0);`
`47`	`47`	`while (state.KeepRunning()) {`
`48`	`48`	`for (int i = 0; i < 1000000; i++) {`
`49`		`- CSHA256().Write(begin_ptr(in), in.size()).Finalize(&in[0]);`
	`49`	`+ CSHA256().Write(in.data(), in.size()).Finalize(&in[0]);`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`
`@@ -56,7 +56,7 @@ static void SHA512(benchmark::State& state)`
`56`	`56`	`uint8_t hash[CSHA512::OUTPUT_SIZE];`
`57`	`57`	`std::vector<uint8_t> in(BUFFER_SIZE,0);`
`58`	`58`	`while (state.KeepRunning())`
`59`		`- CSHA512().Write(begin_ptr(in), in.size()).Finalize(hash);`
	`59`	`+ CSHA512().Write(in.data(), in.size()).Finalize(hash);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`static void SipHash_32b(benchmark::State& state)`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(base58_EncodeBase58)`
`39`	`39`	`std::vector<unsigned char> sourcedata = ParseHex(test[0].get_str());`
`40`	`40`	`std::string base58string = test[1].get_str();`
`41`	`41`	`BOOST_CHECK_MESSAGE(`
`42`		`- EncodeBase58(begin_ptr(sourcedata), end_ptr(sourcedata)) == base58string,`
	`42`	`+ EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size()) == base58string,`
`43`	`43`	`strTest);`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -176,10 +176,10 @@ void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScript`
`176`	`176`	`int libconsensus_flags = flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;`
`177`	`177`	`if (libconsensus_flags == flags) {`
`178`	`178`	`if (flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS) {`
`179`		`- BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(begin_ptr(scriptPubKey), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);`
	`179`	`+ BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);`
`180`	`180`	`} else {`
`181`		`- BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(begin_ptr(scriptPubKey), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);`
`182`		`- BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(begin_ptr(scriptPubKey), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect,message);`
	`181`	`+ BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect, message);`
	`182`	`+ BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, NULL) == expect,message);`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -501,10 +501,10 @@ static std::vector<uint8_t> ComputeResponse(const std::string &key, const std::v`
`501`	`501`	`{`
`502`	`502`	`CHMAC_SHA256 computeHash((const uint8_t*)key.data(), key.size());`
`503`	`503`	`std::vector<uint8_t> computedHash(CHMAC_SHA256::OUTPUT_SIZE, 0);`
`504`		`- computeHash.Write(begin_ptr(cookie), cookie.size());`
`505`		`- computeHash.Write(begin_ptr(clientNonce), clientNonce.size());`
`506`		`- computeHash.Write(begin_ptr(serverNonce), serverNonce.size());`
`507`		`- computeHash.Finalize(begin_ptr(computedHash));`
	`504`	`+ computeHash.Write(cookie.data(), cookie.size());`
	`505`	`+ computeHash.Write(clientNonce.data(), clientNonce.size());`
	`506`	`+ computeHash.Write(serverNonce.data(), serverNonce.size());`
	`507`	`+ computeHash.Finalize(computedHash.data());`
`508`	`508`	`return computedHash;`
`509`	`509`	`}`
`510`	`510`