Merge pull request #1617 from denravonska/fix-namespace-pollution

jamescowens · web-flow · commit 81f8eb50f120 · 2019-12-26T15:42:24.000-05:00
Fix std namespace pollution.
diff --git a/src/contract/contract.cpp b/src/contract/contract.cpp
@@ -140,8 +140,8 @@ std::string executeRain(std::string sRecipients)
 {
     CWalletTx wtx;
     wtx.mapValue["comment"] = "Rain";
-    set<CBitcoinAddress> setAddress;
-    vector<pair<CScript, int64_t> > vecSend;
+    std::set<CBitcoinAddress> setAddress;
+    std::vector<std::pair<CScript, int64_t> > vecSend;
     std::string sRainCommand = ExtractXML(sRecipients,"<RAIN>","</RAIN>");
     std::string sRainMessage = MakeSafeMessage(ExtractXML(sRecipients,"<RAINMESSAGE>","</RAINMESSAGE>"));
     std::string sRain = "<NARR>Project Rain: " + sRainMessage + "</NARR>";
@@ -172,18 +172,18 @@ std::string executeRain(std::string sRecipients)
                 {
                     CBitcoinAddress address(sAddress);
                     if (!address.IsValid())
-                        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("Invalid Gridcoin address: ")+sAddress);
+                        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Gridcoin address: ")+sAddress);
 
                     if (setAddress.count(address))
-                        throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+sAddress);
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ")+sAddress);
 
                     setAddress.insert(address);
                     dTotalToSend += dAmount;
                     int64_t nAmount = AmountFromDouble(dAmount);
                     CScript scriptPubKey;
                     scriptPubKey.SetDestination(address.Get());
                     totalAmount += nAmount;
-                    vecSend.push_back(make_pair(scriptPubKey, nAmount));
+                    vecSend.push_back(std::make_pair(scriptPubKey, nAmount));
                 }
             }
         }
diff --git a/src/rpcclient.cpp b/src/rpcclient.cpp
@@ -60,8 +60,8 @@ UniValue CallRPC(const string& strMethod, const UniValue& params)
     mapRequestHeaders["Authorization"] = string("Basic ") + strUserPass64;
 
     // Send request
-    string strRequest = JSONRPCRequest(strMethod, params, 1);
-    string strPost = HTTPPost(strRequest, mapRequestHeaders);
+    std::string strRequest = JSONRPCRequest(strMethod, params, 1);
+    std::string strPost = HTTPPost(strRequest, mapRequestHeaders);
     stream << strPost << std::flush;
 
     // Receive HTTP reply status
diff --git a/src/rpcprotocol.cpp b/src/rpcprotocol.cpp
@@ -32,9 +32,9 @@
 // and to be compatible with other JSON-RPC implementations.
 //
 
-string HTTPPost(const string& strMsg, const map<string,string>& mapRequestHeaders)
+std::string HTTPPost(const std::string& strMsg, const std::map<std::string,std::string>& mapRequestHeaders)
 {
-    ostringstream s;
+    std::ostringstream s;
     s << "POST / HTTP/1.1\r\n"
       << "User-Agent: gridcoin-json-rpc/" << FormatFullVersion() << "\r\n"
       << "Host: 127.0.0.1\r\n"
@@ -49,20 +49,20 @@ string HTTPPost(const string& strMsg, const map<string,string>& mapRequestHeader
     return s.str();
 }
 
-string rfc1123Time()
+std::string rfc1123Time()
 {
     char buffer[64];
     time_t now;
     time(&now);
     struct tm* now_gmt = gmtime(&now);
-    string locale(setlocale(LC_TIME, NULL));
+    std::string locale(setlocale(LC_TIME, NULL));
     setlocale(LC_TIME, "C"); // we want POSIX (aka "C") weekday/month strings
     strftime(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S +0000", now_gmt);
     setlocale(LC_TIME, locale.c_str());
-    return string(buffer);
+    return std::string(buffer);
 }
 
-string HTTPReply(int nStatus, const string& strMsg, bool keepalive)
+std::string HTTPReply(int nStatus, const std::string& strMsg, bool keepalive)
 {
     if (nStatus == HTTP_UNAUTHORIZED)
         return strprintf("HTTP/1.0 401 Authorization Required\r\n"
@@ -106,22 +106,22 @@ string HTTPReply(int nStatus, const string& strMsg, bool keepalive)
         strMsg);
 }
 
-int ReadHTTPHeaders(std::basic_istream<char>& stream, map<string, string>& mapHeadersRet)
+int ReadHTTPHeaders(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet)
 {
     int nLen = 0;
     while (true)
     {
-        string str;
+        std::string str;
         std::getline(stream, str);
         if (str.empty() || str == "\r")
             break;
-        string::size_type nColon = str.find(":");
-        if (nColon != string::npos)
+        std::string::size_type nColon = str.find(":");
+        if (nColon != std::string::npos)
         {
-            string strHeader = str.substr(0, nColon);
+            std::string strHeader = str.substr(0, nColon);
             boost::trim(strHeader);
             boost::to_lower(strHeader);
-            string strValue = str.substr(nColon+1);
+            std::string strValue = str.substr(nColon+1);
             boost::trim(strValue);
             mapHeadersRet[strHeader] = strValue;
             if (strHeader == "content-length")
@@ -132,13 +132,13 @@ int ReadHTTPHeaders(std::basic_istream<char>& stream, map<string, string>& mapHe
 }
 
 bool ReadHTTPRequestLine(std::basic_istream<char>& stream, int &proto,
-                         string& http_method, string& http_uri)
+                         std::string& http_method, std::string& http_uri)
 {
-    string str;
-    getline(stream, str);
+    std::string str;
+    std::getline(stream, str);
 
     // HTTP request line is space-delimited
-    vector<string> vWords;
+    std::vector<std::string> vWords;
     boost::split(vWords, str, boost::is_any_of(" "));
     if (vWords.size() < 2)
         return false;
@@ -154,7 +154,7 @@ bool ReadHTTPRequestLine(std::basic_istream<char>& stream, int &proto,
         return false;
 
     // parse proto, if present
-    string strProto = "";
+    std::string strProto;
     if (vWords.size() > 2)
         strProto = vWords[2];
 
@@ -168,9 +168,9 @@ bool ReadHTTPRequestLine(std::basic_istream<char>& stream, int &proto,
 
 int ReadHTTPStatus(std::basic_istream<char>& stream, int &proto)
 {
-    string str;
-    getline(stream, str);
-    vector<string> vWords;
+    std::string str;
+    std::getline(stream, str);
+    std::vector<std::string> vWords;
     boost::split(vWords, str, boost::is_any_of(" "));
     if (vWords.size() < 2)
         return HTTP_INTERNAL_SERVER_ERROR;
@@ -181,8 +181,8 @@ int ReadHTTPStatus(std::basic_istream<char>& stream, int &proto)
     return atoi(vWords[1].c_str());
 }
 
-int ReadHTTPMessage(std::basic_istream<char>& stream, map<string,
-                    string>& mapHeadersRet, string& strMessageRet,
+int ReadHTTPMessage(std::basic_istream<char>& stream, std::map<std::string,
+                    std::string>& mapHeadersRet, std::string& strMessageRet,
                     int nProto)
 {
     mapHeadersRet.clear();
@@ -196,12 +196,12 @@ int ReadHTTPMessage(std::basic_istream<char>& stream, map<string,
     // Read message
     if (nLen > 0)
     {
-        vector<char> vch(nLen);
+        std::vector<char> vch(nLen);
         stream.read(&vch[0], nLen);
-        strMessageRet = string(vch.begin(), vch.end());
+        strMessageRet = std::string(vch.begin(), vch.end());
     }
 
-    string sConHdr = mapHeadersRet["connection"];
+    std::string sConHdr = mapHeadersRet["connection"];
 
     if ((sConHdr != "close") && (sConHdr != "keep-alive"))
     {
@@ -224,7 +224,7 @@ int ReadHTTPMessage(std::basic_istream<char>& stream, map<string,
 // http://www.codeproject.com/KB/recipes/JSON_Spirit.aspx
 //
 
-string JSONRPCRequest(const string& strMethod, const UniValue& params, const UniValue& id)
+std::string JSONRPCRequest(const std::string& strMethod, const UniValue& params, const UniValue& id)
 {
     UniValue request(UniValue::VOBJ);
     request.push_back(Pair("method", strMethod));
@@ -245,13 +245,13 @@ UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, const Un
     return reply;
 }
 
-string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id)
+std::string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id)
 {
     UniValue reply = JSONRPCReplyObj(result, error, id);
     return reply.write() + "\n";
 }
 
-UniValue JSONRPCError(int code, const string& message)
+UniValue JSONRPCError(int code, const std::string& message)
 {
     UniValue error(UniValue::VOBJ);
     error.pushKV("code", code);
diff --git a/src/rpcprotocol.h b/src/rpcprotocol.h
@@ -16,8 +16,6 @@
 
 #include <univalue.h>
 
-using namespace std;
-
 // Boost Support for 1.70+
 #if BOOST_VERSION >= 107000
     #define GetIOService(s) ((boost::asio::io_context&)(s).get_executor().context())
@@ -182,16 +180,16 @@ class AcceptedConnectionImpl : public AcceptedConnection
     boost::iostreams::stream< SSLIOStreamDevice<Protocol> > _stream;
 };
 
-string HTTPPost(const string& strMsg, const map<string,string>& mapRequestHeaders);
-string HTTPReply(int nStatus, const string& strMsg, bool keepalive);
+std::string HTTPPost(const std::string& strMsg, const std::map<std::string,std::string>& mapRequestHeaders);
+std::string HTTPReply(int nStatus, const std::string& strMsg, bool keepalive);
 bool ReadHTTPRequestLine(std::basic_istream<char>& stream, int &proto,
                          std::string& http_method, std::string& http_uri);
 int ReadHTTPStatus(std::basic_istream<char>& stream, int &proto);
 int ReadHTTPHeaders(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet);
 int ReadHTTPMessage(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet,
                     std::string& strMessageRet, int nProto);
-string JSONRPCRequest(const string& strMethod, const UniValue& params, const UniValue& id);
+std::string JSONRPCRequest(const std::string& strMethod, const UniValue& params, const UniValue& id);
 UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, const UniValue& id);
-string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id);
+std::string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id);
 UniValue JSONRPCError(int code, const std::string& message);
 
diff --git a/src/scraper/scraper.cpp b/src/scraper/scraper.cpp
@@ -323,7 +323,7 @@ class ScraperLogger
                     std::string sFilename = DirEntry.path().filename().string();
                     size_t FoundPos = sFilename.find("scraper");
 
-                    if (FoundPos != string::npos) SortedDirEntries.insert(DirEntry);
+                    if (FoundPos != std::string::npos) SortedDirEntries.insert(DirEntry);
                 }
 
                 // Now iterate through set of filtered filenames. Delete all files greater than retention count.
@@ -3842,7 +3842,7 @@ bool ScraperConstructConvergedManifest(ConvergedManifest& StructConvergedManifes
     mmCSManifestsBinnedByScraper mMapCSManifestsBinnedByScraper = ScraperCullAndBinCScraperManifests();
     
     // Do a map for unique manifest times ordered by descending time then content hash.
-    std::multimap<int64_t, uint256, greater<int64_t>> mManifestsBinnedByTime;
+    std::multimap<int64_t, uint256, std::greater<int64_t>> mManifestsBinnedByTime;
     // and also by content hash, then scraperID and manifest (not content) hash.
     std::multimap<uint256, std::pair<ScraperID, uint256>> mManifestsBinnedbyContent;
     std::multimap<uint256, std::pair<ScraperID, uint256>>::iterator convergence;
@@ -4112,7 +4112,7 @@ bool ScraperConstructConvergedManifestByProject(const NN::WhitelistSnapshot& pro
         // parts, so we will need to choose the latest consensus block by manifest time. This will occur naturally below if tracked in
         // this manner. We will also want the BeaconList from the associated manifest.
         // ------ manifest time --- object hash - consensus block hash - manifest hash.
-        std::multimap<int64_t, std::tuple<uint256, uint256, uint256>, greater<int64_t>> mProjectObjectsBinnedByTime;
+        std::multimap<int64_t, std::tuple<uint256, uint256, uint256>, std::greater<int64_t>> mProjectObjectsBinnedByTime;
         // and also by project object (content) hash, then scraperID and project.
         std::multimap<uint256, std::pair<ScraperID, std::string>> mProjectObjectsBinnedbyContent;
         std::multimap<uint256, std::pair<ScraperID, std::string>>::iterator ProjectConvergence;
diff --git a/src/scraper_net.cpp b/src/scraper_net.cpp
@@ -396,7 +396,7 @@ void CScraperManifest::UnserializeCheck(CDataStream& ss, unsigned int& banscore_
 {
     const auto pbegin = ss.begin();
 
-    vector<uint256> vph;
+    std::vector<uint256> vph;
     ss>>vph;
     ss>> pubkey;
     ss>> sCManifestName;

Original file line number	Diff line number	Diff line change
`@@ -396,7 +396,7 @@ void CScraperManifest::UnserializeCheck(CDataStream& ss, unsigned int& banscore_`
`396`	`396`	`{`
`397`	`397`	`const auto pbegin = ss.begin();`
`398`	`398`
`399`		`- vector<uint256> vph;`
	`399`	`+ std::vector<uint256> vph;`
`400`	`400`	`ss>>vph;`
`401`	`401`	`ss>> pubkey;`
`402`	`402`	`ss>> sCManifestName;`