BTCPrivate
/
BTCP-Rebase
mirror of https://github.com/BTCPrivate/BTCP-Rebase.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactor: Remove using namespace <xxx> from util*

This commit is contained in:
Karl-Johan Alm 2017-01-27 10:34:06 +09:00
parent 8a5228197c
commit a57845c20e
No known key found for this signature in database
GPG Key ID: 57AF762DB3353322
4 changed files with 46 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/util.cpp
View File

@ -97,15 +97,15 @@ namespace boost {
} // namespace boost } // namespace boost
using namespace std;
const char * const BITCOIN_CONF_FILENAME = "bitcoin.conf"; const char * const BITCOIN_CONF_FILENAME = "bitcoin.conf";
const char * const BITCOIN_PID_FILENAME = "bitcoind.pid"; const char * const BITCOIN_PID_FILENAME = "bitcoind.pid";
CCriticalSection cs_args; CCriticalSection cs_args;
map<string, string> mapArgs; std::map<std::string, std::string> mapArgs;
static map<string, vector<string> > _mapMultiArgs; static std::map<std::string, std::vector<std::string> > _mapMultiArgs;
const map<string, vector<string> >& mapMultiArgs = _mapMultiArgs; const std::map<std::string, std::vector<std::string> >& mapMultiArgs = _mapMultiArgs;
bool fDebug = false; bool fDebug = false;
bool fPrintToConsole = false; bool fPrintToConsole = false;
bool fPrintToDebugLog = true; bool fPrintToDebugLog = true;
@ -191,7 +191,7 @@ static boost::once_flag debugPrintInitFlag = BOOST_ONCE_INIT;
*/ */
static FILE* fileout = NULL; static FILE* fileout = NULL;
static boost::mutex* mutexDebugLog = NULL; static boost::mutex* mutexDebugLog = NULL;
static list<string> *vMsgsBeforeOpenLog; static std::list<std::string>* vMsgsBeforeOpenLog;
static int FileWriteStr(const std::string &str, FILE *fp) static int FileWriteStr(const std::string &str, FILE *fp)
{ {
@ -202,7 +202,7 @@ static void DebugPrintInit()
{ {
assert(mutexDebugLog == NULL); assert(mutexDebugLog == NULL);
mutexDebugLog = new boost::mutex(); mutexDebugLog = new boost::mutex();
vMsgsBeforeOpenLog = new list<string>; vMsgsBeforeOpenLog = new std::list<std::string>;
} }
void OpenDebugLog() void OpenDebugLog()
@ -238,22 +238,22 @@ bool LogAcceptCategory(const char* category)
// This helps prevent issues debugging global destructors, // This helps prevent issues debugging global destructors,
// where mapMultiArgs might be deleted before another // where mapMultiArgs might be deleted before another
// global destructor calls LogPrint() // global destructor calls LogPrint()
static boost::thread_specific_ptr<set<string> > ptrCategory; static boost::thread_specific_ptr<std::set<std::string> > ptrCategory;
if (ptrCategory.get() == NULL) if (ptrCategory.get() == NULL)
{ {
if (mapMultiArgs.count("-debug")) { if (mapMultiArgs.count("-debug")) {
const vector<string>& categories = mapMultiArgs.at("-debug"); const std::vector<std::string>& categories = mapMultiArgs.at("-debug");
ptrCategory.reset(new set<string>(categories.begin(), categories.end())); ptrCategory.reset(new std::set<std::string>(categories.begin(), categories.end()));
// thread_specific_ptr automatically deletes the set when the thread ends. // thread_specific_ptr automatically deletes the set when the thread ends.
} else } else
ptrCategory.reset(new set<string>()); ptrCategory.reset(new std::set<std::string>());
} }
const set<string>& setCategories = *ptrCategory.get(); const std::set<std::string>& setCategories = *ptrCategory.get();
// if not debugging everything and not debugging specific category, LogPrint does nothing. // if not debugging everything and not debugging specific category, LogPrint does nothing.
if (setCategories.count(string("")) == 0 && if (setCategories.count(std::string("")) == 0 &&
setCategories.count(string("1")) == 0 && setCategories.count(std::string("1")) == 0 &&
setCategories.count(string(category)) == 0) setCategories.count(std::string(category)) == 0)
return false; return false;
} }
return true; return true;
@ -266,7 +266,7 @@ bool LogAcceptCategory(const char* category)
*/ */
static std::string LogTimestampStr(const std::string &str, std::atomic_bool *fStartedNewLine) static std::string LogTimestampStr(const std::string &str, std::atomic_bool *fStartedNewLine)
{ {
string strStamped; std::string strStamped;
if (!fLogTimestamps) if (!fLogTimestamps)
return str; return str;
@ -293,7 +293,7 @@ int LogPrintStr(const std::string &str)
int ret = 0; // Returns total number of characters written int ret = 0; // Returns total number of characters written
static std::atomic_bool fStartedNewLine(true); static std::atomic_bool fStartedNewLine(true);
string strTimestamped = LogTimestampStr(str, &fStartedNewLine); std::string strTimestamped = LogTimestampStr(str, &fStartedNewLine);
if (fPrintToConsole) if (fPrintToConsole)
{ {
@ -561,14 +561,14 @@ void ReadConfigFile(const std::string& confPath)
{ {
LOCK(cs_args); LOCK(cs_args);
set<string> setOptions; std::set<std::string> setOptions;
setOptions.insert("*"); setOptions.insert("*");
for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it) for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
{ {
// Don't overwrite existing settings so command line settings override bitcoin.conf // Don't overwrite existing settings so command line settings override bitcoin.conf
string strKey = string("-") + it->string_key; std::string strKey = std::string("-") + it->string_key;
string strValue = it->value[0]; std::string strValue = it->value[0];
InterpretNegativeSetting(strKey, strValue); InterpretNegativeSetting(strKey, strValue);
if (mapArgs.count(strKey) == 0) if (mapArgs.count(strKey) == 0)
mapArgs[strKey] = strValue; mapArgs[strKey] = strValue;

8
src/utilmoneystr.cpp
View File

@ -9,8 +9,6 @@
#include "tinyformat.h" #include "tinyformat.h"
#include "utilstrencodings.h" #include "utilstrencodings.h"
using namespace std;
std::string FormatMoney(const CAmount& n) std::string FormatMoney(const CAmount& n)
{ {
// Note: not using straight sprintf here because we do NOT want // Note: not using straight sprintf here because we do NOT want
@ -18,7 +16,7 @@ std::string FormatMoney(const CAmount& n)
int64_t n_abs = (n > 0 ? n : -n); int64_t n_abs = (n > 0 ? n : -n);
int64_t quotient = n_abs/COIN; int64_t quotient = n_abs/COIN;
int64_t remainder = n_abs%COIN; int64_t remainder = n_abs%COIN;
string str = strprintf("%d.%08d", quotient, remainder); std::string str = strprintf("%d.%08d", quotient, remainder);
// Right-trim excess zeros before the decimal point: // Right-trim excess zeros before the decimal point:
int nTrim = 0; int nTrim = 0;
@ -33,14 +31,14 @@ std::string FormatMoney(const CAmount& n)
} }
bool ParseMoney(const string& str, CAmount& nRet) bool ParseMoney(const std::string& str, CAmount& nRet)
{ {
return ParseMoney(str.c_str(), nRet); return ParseMoney(str.c_str(), nRet);
} }
bool ParseMoney(const char* pszIn, CAmount& nRet) bool ParseMoney(const char* pszIn, CAmount& nRet)
{ {
string strWhole; std::string strWhole;
int64_t nUnits = 0; int64_t nUnits = 0;
const char* p = pszIn; const char* p = pszIn;
while (isspace(*p)) while (isspace(*p))

50
src/utilstrencodings.cpp
View File

@ -12,20 +12,18 @@
#include <errno.h> #include <errno.h>
#include <limits> #include <limits>
using namespace std; static const std::string CHARS_ALPHA_NUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
static const string CHARS_ALPHA_NUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; static const std::string SAFE_CHARS[] =
static const string SAFE_CHARS[] =
{ {
CHARS_ALPHA_NUM + " .,;-_/:?@()", // SAFE_CHARS_DEFAULT CHARS_ALPHA_NUM + " .,;-_/:?@()", // SAFE_CHARS_DEFAULT
CHARS_ALPHA_NUM + " .,;-_?@", // SAFE_CHARS_UA_COMMENT CHARS_ALPHA_NUM + " .,;-_?@", // SAFE_CHARS_UA_COMMENT
CHARS_ALPHA_NUM + ".-_", // SAFE_CHARS_FILENAME CHARS_ALPHA_NUM + ".-_", // SAFE_CHARS_FILENAME
}; };
string SanitizeString(const string& str, int rule) std::string SanitizeString(const std::string& str, int rule)
{ {
string strResult; std::string strResult;
for (std::string::size_type i = 0; i < str.size(); i++) for (std::string::size_type i = 0; i < str.size(); i++)
{ {
if (SAFE_CHARS[rule].find(str[i]) != std::string::npos) if (SAFE_CHARS[rule].find(str[i]) != std::string::npos)
@ -57,7 +55,7 @@ signed char HexDigit(char c)
return p_util_hexdigit[(unsigned char)c]; return p_util_hexdigit[(unsigned char)c];
} }
bool IsHex(const string& str) bool IsHex(const std::string& str)
{ {
for(std::string::const_iterator it(str.begin()); it != str.end(); ++it) for(std::string::const_iterator it(str.begin()); it != str.end(); ++it)
{ {
@ -67,10 +65,10 @@ bool IsHex(const string& str)
return (str.size() > 0) && (str.size()%2 == 0); return (str.size() > 0) && (str.size()%2 == 0);
} }
vector<unsigned char> ParseHex(const char* psz) std::vector<unsigned char> ParseHex(const char* psz)
{ {
// convert hex dump to vector // convert hex dump to vector
vector<unsigned char> vch; std::vector<unsigned char> vch;
while (true) while (true)
{ {
while (isspace(*psz)) while (isspace(*psz))
@ -88,16 +86,16 @@ vector<unsigned char> ParseHex(const char* psz)
return vch; return vch;
} }
vector<unsigned char> ParseHex(const string& str) std::vector<unsigned char> ParseHex(const std::string& str)
{ {
return ParseHex(str.c_str()); return ParseHex(str.c_str());
} }
string EncodeBase64(const unsigned char* pch, size_t len) std::string EncodeBase64(const unsigned char* pch, size_t len)
{ {
static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
string strRet=""; std::string strRet = "";
strRet.reserve((len+2)/3*4); strRet.reserve((len+2)/3*4);
int mode=0, left=0; int mode=0, left=0;
@ -139,12 +137,12 @@ string EncodeBase64(const unsigned char* pch, size_t len)
return strRet; return strRet;
} }
string EncodeBase64(const string& str) std::string EncodeBase64(const std::string& str)
{ {
return EncodeBase64((const unsigned char*)str.c_str(), str.size()); return EncodeBase64((const unsigned char*)str.c_str(), str.size());
} }
vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid) std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
{ {
static const int decode64_table[256] = static const int decode64_table[256] =
{ {
@ -166,7 +164,7 @@ vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
if (pfInvalid) if (pfInvalid)
*pfInvalid = false; *pfInvalid = false;
vector<unsigned char> vchRet; std::vector<unsigned char> vchRet;
vchRet.reserve(strlen(p)*3/4); vchRet.reserve(strlen(p)*3/4);
int mode = 0; int mode = 0;
@ -227,17 +225,17 @@ vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
return vchRet; return vchRet;
} }
string DecodeBase64(const string& str) std::string DecodeBase64(const std::string& str)
{ {
vector<unsigned char> vchRet = DecodeBase64(str.c_str()); std::vector<unsigned char> vchRet = DecodeBase64(str.c_str());
return (vchRet.size() == 0) ? string() : string((const char*)&vchRet[0], vchRet.size()); return (vchRet.size() == 0) ? std::string() : std::string((const char*)&vchRet[0], vchRet.size());
} }
string EncodeBase32(const unsigned char* pch, size_t len) std::string EncodeBase32(const unsigned char* pch, size_t len)
{ {
static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567"; static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
string strRet=""; std::string strRet="";
strRet.reserve((len+4)/5*8); strRet.reserve((len+4)/5*8);
int mode=0, left=0; int mode=0, left=0;
@ -292,12 +290,12 @@ string EncodeBase32(const unsigned char* pch, size_t len)
return strRet; return strRet;
} }
string EncodeBase32(const string& str) std::string EncodeBase32(const std::string& str)
{ {
return EncodeBase32((const unsigned char*)str.c_str(), str.size()); return EncodeBase32((const unsigned char*)str.c_str(), str.size());
} }
vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid) std::vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
{ {
static const int decode32_table[256] = static const int decode32_table[256] =
{ {
@ -319,7 +317,7 @@ vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
if (pfInvalid) if (pfInvalid)
*pfInvalid = false; *pfInvalid = false;
vector<unsigned char> vchRet; std::vector<unsigned char> vchRet;
vchRet.reserve((strlen(p))*5/8); vchRet.reserve((strlen(p))*5/8);
int mode = 0; int mode = 0;
@ -414,10 +412,10 @@ vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
return vchRet; return vchRet;
} }
string DecodeBase32(const string& str) std::string DecodeBase32(const std::string& str)
{ {
vector<unsigned char> vchRet = DecodeBase32(str.c_str()); std::vector<unsigned char> vchRet = DecodeBase32(str.c_str());
return (vchRet.size() == 0) ? string() : string((const char*)&vchRet[0], vchRet.size()); return (vchRet.size() == 0) ? std::string() : std::string((const char*)&vchRet[0], vchRet.size());
} }
static bool ParsePrechecks(const std::string& str) static bool ParsePrechecks(const std::string& str)

2
src/utiltime.cpp
View File

@ -12,8 +12,6 @@
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread.hpp> #include <boost/thread.hpp>
using namespace std;
static int64_t nMockTime = 0; //!< For unit testing static int64_t nMockTime = 0; //!< For unit testing
int64_t GetTime() int64_t GetTime()