programmable-versionstring

raw
genesis                 1 // Copyright (c) 2009-2010 Satoshi Nakamoto
genesis                 2 // Copyright (c) 2009-2012 The Bitcoin developers
genesis                 3 // Distributed under the MIT/X11 software license, see the accompanying
genesis                 4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
genesis                 5 #ifndef BITCOIN_UTIL_H
genesis                 6 #define BITCOIN_UTIL_H
genesis                 7 
genesis                 8 #include "uint256.h"
genesis                 9 
asciilifeform-kil...   10 #include <stdint.h>
genesis                11 #include <sys/types.h>
genesis                12 #include <sys/time.h>
genesis                13 #include <sys/resource.h>
genesis                14 #include <map>
genesis                15 #include <vector>
genesis                16 #include <string>
genesis                17 
genesis                18 #include <boost/thread.hpp>
genesis                19 #include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
genesis                20 #include <boost/date_time/gregorian/gregorian_types.hpp>
genesis                21 #include <boost/date_time/posix_time/posix_time_types.hpp>
genesis                22 
genesis                23 #include <openssl/sha.h>
genesis                24 #include <openssl/ripemd.h>
genesis                25 
genesis                26 
genesis                27 typedef long long  int64;
genesis                28 typedef unsigned long long  uint64;
bitcoin-asciilife...   29 
genesis                30 #define __forceinline  inline
genesis                31 
genesis                32 #define loop                for (;;)
genesis                33 #define BEGIN(a)            ((char*)&(a))
genesis                34 #define END(a)              ((char*)&((&(a))[1]))
genesis                35 #define UBEGIN(a)           ((unsigned char*)&(a))
genesis                36 #define UEND(a)             ((unsigned char*)&((&(a))[1]))
genesis                37 #define ARRAYLEN(array)     (sizeof(array)/sizeof((array)[0]))
genesis                38 #define printf              OutputDebugStringF
genesis                39 
genesis                40 #ifdef snprintf
genesis                41 #undef snprintf
genesis                42 #endif
genesis                43 #define snprintf my_snprintf
genesis                44 
genesis                45 #ifndef PRI64d
genesis                46 #define PRI64d  "lld"
genesis                47 #define PRI64u  "llu"
genesis                48 #define PRI64x  "llx"
genesis                49 #endif
genesis                50 
genesis                51 // This is needed because the foreach macro can't get over the comma in pair<t1, t2>
genesis                52 #define PAIRTYPE(t1, t2)    std::pair<t1, t2>
genesis                53 
genesis                54 // Align by increasing pointer, must have extra space at end of buffer
genesis                55 template <size_t nBytes, typename T>
genesis                56 T* alignup(T* p)
genesis                57 {
genesis                58     union
genesis                59     {
genesis                60         T* ptr;
genesis                61         size_t n;
genesis                62     } u;
genesis                63     u.ptr = p;
genesis                64     u.n = (u.n + (nBytes-1)) & ~(nBytes-1);
genesis                65     return u.ptr;
genesis                66 }
genesis                67 
genesis                68 #define WSAGetLastError()   errno
genesis                69 #define WSAEINVAL           EINVAL
genesis                70 #define WSAEALREADY         EALREADY
genesis                71 #define WSAEWOULDBLOCK      EWOULDBLOCK
genesis                72 #define WSAEMSGSIZE         EMSGSIZE
genesis                73 #define WSAEINTR            EINTR
genesis                74 #define WSAEINPROGRESS      EINPROGRESS
genesis                75 #define WSAEADDRINUSE       EADDRINUSE
genesis                76 #define WSAENOTSOCK         EBADF
genesis                77 #define INVALID_SOCKET      (SOCKET)(~0)
genesis                78 #define SOCKET_ERROR        -1
genesis                79 typedef u_int SOCKET;
genesis                80 #define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)
genesis                81 #define strlwr(psz)         to_lower(psz)
genesis                82 #define _strlwr(psz)        to_lower(psz)
genesis                83 #define MAX_PATH            1024
genesis                84 #define Beep(n1,n2)         (0)
genesis                85 inline void Sleep(int64 n)
genesis                86 {
genesis                87     /*Boost has a year 2038 problem— if the request sleep time is past epoch+2^31 seconds the sleep returns instantly.
genesis                88       So we clamp our sleeps here to 10 years and hope that boost is fixed by 2028.*/
genesis                89     boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(n>315576000000LL?315576000000LL:n));
genesis                90 }
bitcoin-asciilife...   91 
genesis                92 
genesis                93 inline int myclosesocket(SOCKET& hSocket)
genesis                94 {
genesis                95     if (hSocket == INVALID_SOCKET)
genesis                96         return WSAENOTSOCK;
genesis                97     int ret = close(hSocket);
genesis                98     hSocket = INVALID_SOCKET;
genesis                99     return ret;
genesis               100 }
genesis               101 #define closesocket(s)      myclosesocket(s)
genesis               102 inline const char* _(const char* psz)
genesis               103 {
genesis               104     return psz;
genesis               105 }
bitcoin-asciilife...  106 
genesis               107 
genesis               108 extern std::map<std::string, std::string> mapArgs;
genesis               109 extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
genesis               110 extern bool fDebug;
genesis               111 extern bool fPrintToConsole;
genesis               112 extern bool fPrintToDebugger;
asciilifeform_and...  113 extern bool fCanEat;
asciilifeform_add...  114 extern bool fVerifyAll;
genesis               115 extern char pszSetDataDir[MAX_PATH];
genesis               116 extern bool fRequestShutdown;
genesis               117 extern bool fShutdown;
genesis               118 extern bool fDaemon;
genesis               119 extern bool fServer;
genesis               120 extern bool fCommandLine;
genesis               121 extern std::string strMiscWarning;
genesis               122 extern bool fNoListen;
genesis               123 extern bool fLogTimestamps;
programmable-vers...  124 extern std::string CLIENT_NAME;
genesis               125 
genesis               126 void RandAddSeed();
genesis               127 void RandAddSeedPerfmon();
genesis               128 int OutputDebugStringF(const char* pszFormat, ...);
genesis               129 int my_snprintf(char* buffer, size_t limit, const char* format, ...);
genesis               130 std::string strprintf(const std::string &format, ...);
genesis               131 bool error(const std::string &format, ...);
genesis               132 void LogException(std::exception* pex, const char* pszThread);
genesis               133 void PrintException(std::exception* pex, const char* pszThread);
genesis               134 void PrintExceptionContinue(std::exception* pex, const char* pszThread);
genesis               135 void ParseString(const std::string& str, char c, std::vector<std::string>& v);
genesis               136 std::string FormatMoney(int64 n, bool fPlus=false);
genesis               137 bool ParseMoney(const std::string& str, int64& nRet);
genesis               138 bool ParseMoney(const char* pszIn, int64& nRet);
genesis               139 std::vector<unsigned char> ParseHex(const char* psz);
genesis               140 std::vector<unsigned char> ParseHex(const std::string& str);
genesis               141 std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL);
genesis               142 std::string DecodeBase64(const std::string& str);
genesis               143 std::string EncodeBase64(const unsigned char* pch, size_t len);
genesis               144 std::string EncodeBase64(const std::string& str);
genesis               145 void ParseParameters(int argc, char* argv[]);
genesis               146 const char* wxGetTranslation(const char* psz);
genesis               147 bool WildcardMatch(const char* psz, const char* mask);
genesis               148 bool WildcardMatch(const std::string& str, const std::string& mask);
genesis               149 int GetFilesize(FILE* file);
genesis               150 void GetDataDir(char* pszDirRet);
genesis               151 std::string GetConfigFile();
genesis               152 std::string GetPidFile();
genesis               153 void CreatePidFile(std::string pidFile, pid_t pid);
genesis               154 void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
genesis               155 std::string GetDefaultDataDir();
genesis               156 std::string GetDataDir();
genesis               157 void ShrinkDebugFile();
genesis               158 int GetRandInt(int nMax);
genesis               159 uint64 GetRand(uint64 nMax);
genesis               160 int64 GetTime();
genesis               161 void SetMockTime(int64 nMockTimeIn);
genesis               162 int64 GetAdjustedTime();
genesis               163 void AddTimeData(unsigned int ip, int64 nTime);
genesis               164 std::string FormatFullVersion();
programmable-vers...  165 std::string FormatSubVersion(const std::string& name, int nClientVersion);
genesis               166 
genesis               167 
genesis               168 
genesis               169 
genesis               170 
genesis               171 
genesis               172 
genesis               173 
genesis               174 
genesis               175 
genesis               176 
genesis               177 
genesis               178 
genesis               179 // Wrapper to automatically initialize mutex
genesis               180 class CCriticalSection
genesis               181 {
genesis               182 protected:
genesis               183     boost::interprocess::interprocess_recursive_mutex mutex;
genesis               184 public:
genesis               185     explicit CCriticalSection() { }
genesis               186     ~CCriticalSection() { }
genesis               187     void Enter(const char* pszName, const char* pszFile, int nLine);
genesis               188     void Leave();
genesis               189     bool TryEnter(const char* pszName, const char* pszFile, int nLine);
genesis               190 };
genesis               191 
genesis               192 // Automatically leave critical section when leaving block, needed for exception safety
genesis               193 class CCriticalBlock
genesis               194 {
genesis               195 protected:
genesis               196     CCriticalSection* pcs;
genesis               197 
genesis               198 public:
genesis               199     CCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
genesis               200     {
genesis               201         pcs = &csIn;
genesis               202         pcs->Enter(pszName, pszFile, nLine);
genesis               203     }
genesis               204 
genesis               205     operator bool() const
genesis               206     {
genesis               207         return true;
genesis               208     }
genesis               209 
genesis               210     ~CCriticalBlock()
genesis               211     {
genesis               212         pcs->Leave();
genesis               213     }
genesis               214 };
genesis               215 
genesis               216 #define CRITICAL_BLOCK(cs)     \
genesis               217     if (CCriticalBlock criticalblock = CCriticalBlock(cs, #cs, __FILE__, __LINE__))
genesis               218 
genesis               219 #define ENTER_CRITICAL_SECTION(cs) \
genesis               220     (cs).Enter(#cs, __FILE__, __LINE__)
genesis               221 
genesis               222 #define LEAVE_CRITICAL_SECTION(cs) \
genesis               223     (cs).Leave()
genesis               224 
genesis               225 class CTryCriticalBlock
genesis               226 {
genesis               227 protected:
genesis               228     CCriticalSection* pcs;
genesis               229 
genesis               230 public:
genesis               231     CTryCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
genesis               232     {
genesis               233         pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL);
genesis               234     }
genesis               235 
genesis               236     operator bool() const
genesis               237     {
genesis               238         return Entered();
genesis               239     }
genesis               240 
genesis               241     ~CTryCriticalBlock()
genesis               242     {
genesis               243         if (pcs)
genesis               244         {
genesis               245             pcs->Leave();
genesis               246         }
genesis               247     }
genesis               248     bool Entered() const { return pcs != NULL; }
genesis               249 };
genesis               250 
genesis               251 #define TRY_CRITICAL_BLOCK(cs)     \
genesis               252     if (CTryCriticalBlock criticalblock = CTryCriticalBlock(cs, #cs, __FILE__, __LINE__))
genesis               253 
genesis               254 
genesis               255 
genesis               256 
genesis               257 
genesis               258 
genesis               259 // This is exactly like std::string, but with a custom allocator.
genesis               260 // (secure_allocator<> is defined in serialize.h)
genesis               261 typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
genesis               262 
genesis               263 // This is exactly like std::string, but with a custom allocator.
genesis               264 // (secure_allocator<> is defined in serialize.h)
genesis               265 typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
genesis               266 
genesis               267 
genesis               268 
genesis               269 
genesis               270 
genesis               271 inline std::string i64tostr(int64 n)
genesis               272 {
genesis               273     return strprintf("%"PRI64d, n);
genesis               274 }
genesis               275 
genesis               276 inline std::string itostr(int n)
genesis               277 {
genesis               278     return strprintf("%d", n);
genesis               279 }
genesis               280 
genesis               281 inline int64 atoi64(const char* psz)
genesis               282 {
genesis               283     return strtoll(psz, NULL, 10);
genesis               284 }
genesis               285 
genesis               286 inline int64 atoi64(const std::string& str)
genesis               287 {
genesis               288     return strtoll(str.c_str(), NULL, 10);
genesis               289 }
genesis               290 
genesis               291 inline int atoi(const std::string& str)
genesis               292 {
genesis               293     return atoi(str.c_str());
genesis               294 }
genesis               295 
genesis               296 inline int roundint(double d)
genesis               297 {
genesis               298     return (int)(d > 0 ? d + 0.5 : d - 0.5);
genesis               299 }
genesis               300 
genesis               301 inline int64 roundint64(double d)
genesis               302 {
genesis               303     return (int64)(d > 0 ? d + 0.5 : d - 0.5);
genesis               304 }
genesis               305 
genesis               306 inline int64 abs64(int64 n)
genesis               307 {
genesis               308     return (n >= 0 ? n : -n);
genesis               309 }
genesis               310 
genesis               311 template<typename T>
genesis               312 std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
genesis               313 {
genesis               314     if (itbegin == itend)
genesis               315         return "";
genesis               316     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
genesis               317     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
genesis               318     std::string str;
genesis               319     str.reserve((pend-pbegin) * (fSpaces ? 3 : 2));
genesis               320     for (const unsigned char* p = pbegin; p != pend; p++)
genesis               321         str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);
genesis               322     return str;
genesis               323 }
genesis               324 
genesis               325 inline std::string HexStr(const std::vector<unsigned char>& vch, bool fSpaces=false)
genesis               326 {
genesis               327     return HexStr(vch.begin(), vch.end(), fSpaces);
genesis               328 }
genesis               329 
genesis               330 template<typename T>
genesis               331 std::string HexNumStr(const T itbegin, const T itend, bool f0x=true)
genesis               332 {
genesis               333     if (itbegin == itend)
genesis               334         return "";
genesis               335     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
genesis               336     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
genesis               337     std::string str = (f0x ? "0x" : "");
genesis               338     str.reserve(str.size() + (pend-pbegin) * 2);
genesis               339     for (const unsigned char* p = pend-1; p >= pbegin; p--)
genesis               340         str += strprintf("%02x", *p);
genesis               341     return str;
genesis               342 }
genesis               343 
genesis               344 inline std::string HexNumStr(const std::vector<unsigned char>& vch, bool f0x=true)
genesis               345 {
genesis               346     return HexNumStr(vch.begin(), vch.end(), f0x);
genesis               347 }
genesis               348 
genesis               349 template<typename T>
genesis               350 void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)
genesis               351 {
genesis               352     printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());
genesis               353 }
genesis               354 
genesis               355 inline void PrintHex(const std::vector<unsigned char>& vch, const char* pszFormat="%s", bool fSpaces=true)
genesis               356 {
genesis               357     printf(pszFormat, HexStr(vch, fSpaces).c_str());
genesis               358 }
genesis               359 
genesis               360 inline int64 GetPerformanceCounter()
genesis               361 {
genesis               362     int64 nCounter = 0;
genesis               363     timeval t;
genesis               364     gettimeofday(&t, NULL);
genesis               365     nCounter = t.tv_sec * 1000000 + t.tv_usec;
genesis               366     return nCounter;
genesis               367 }
genesis               368 
genesis               369 inline int64 GetTimeMillis()
genesis               370 {
genesis               371     return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) -
genesis               372             boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds();
genesis               373 }
genesis               374 
genesis               375 inline std::string DateTimeStrFormat(const char* pszFormat, int64 nTime)
genesis               376 {
genesis               377     time_t n = nTime;
genesis               378     struct tm* ptmTime = gmtime(&n);
genesis               379     char pszTime[200];
genesis               380     strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);
genesis               381     return pszTime;
genesis               382 }
genesis               383 
genesis               384 template<typename T>
genesis               385 void skipspaces(T& it)
genesis               386 {
genesis               387     while (isspace(*it))
genesis               388         ++it;
genesis               389 }
genesis               390 
genesis               391 inline bool IsSwitchChar(char c)
genesis               392 {
genesis               393     return c == '-';
genesis               394 }
genesis               395 
genesis               396 inline std::string GetArg(const std::string& strArg, const std::string& strDefault)
genesis               397 {
genesis               398     if (mapArgs.count(strArg))
genesis               399         return mapArgs[strArg];
genesis               400     return strDefault;
genesis               401 }
genesis               402 
genesis               403 inline int64 GetArg(const std::string& strArg, int64 nDefault)
genesis               404 {
genesis               405     if (mapArgs.count(strArg))
genesis               406         return atoi64(mapArgs[strArg]);
genesis               407     return nDefault;
genesis               408 }
genesis               409 
genesis               410 inline bool GetBoolArg(const std::string& strArg, bool fDefault=false)
genesis               411 {
genesis               412     if (mapArgs.count(strArg))
genesis               413     {
genesis               414         if (mapArgs[strArg].empty())
genesis               415             return true;
genesis               416         return (atoi(mapArgs[strArg]) != 0);
genesis               417     }
genesis               418     return fDefault;
genesis               419 }
genesis               420 
genesis               421 /**
genesis               422  * Set an argument if it doesn't already have a value
genesis               423  *
genesis               424  * @param strArg Argument to set (e.g. "-foo")
genesis               425  * @param strValue Value (e.g. "1")
genesis               426  * @return true if argument gets set, false if it already had a value
genesis               427  */
genesis               428 bool SoftSetArg(const std::string& strArg, const std::string& strValue);
genesis               429 
genesis               430 /**
genesis               431  * Set a boolean argument if it doesn't already have a value
genesis               432  *
genesis               433  * @param strArg Argument to set (e.g. "-foo")
genesis               434  * @param fValue Value (e.g. false)
genesis               435  * @return true if argument gets set, false if it already had a value
genesis               436  */
genesis               437 bool SoftSetArg(const std::string& strArg, bool fValue);
genesis               438 
genesis               439 
genesis               440 
genesis               441 
genesis               442 
genesis               443 
genesis               444 
genesis               445 
genesis               446 
genesis               447 inline void heapchk()
genesis               448 {
genesis               449 }
genesis               450 
genesis               451 // Randomize the stack to help protect against buffer overrun exploits
genesis               452 #define IMPLEMENT_RANDOMIZE_STACK(ThreadFn)     \
genesis               453     {                                           \
genesis               454         static char nLoops;                     \
genesis               455         if (nLoops <= 0)                        \
genesis               456             nLoops = GetRand(20) + 1;           \
genesis               457         if (nLoops-- > 1)                       \
genesis               458         {                                       \
genesis               459             ThreadFn;                           \
genesis               460             return;                             \
genesis               461         }                                       \
genesis               462     }
genesis               463 
genesis               464 #define CATCH_PRINT_EXCEPTION(pszFn)     \
genesis               465     catch (std::exception& e) {          \
genesis               466         PrintException(&e, (pszFn));     \
genesis               467     } catch (...) {                      \
genesis               468         PrintException(NULL, (pszFn));   \
genesis               469     }
genesis               470 
genesis               471 
genesis               472 
genesis               473 
genesis               474 
genesis               475 
genesis               476 
genesis               477 
genesis               478 
genesis               479 
genesis               480 template<typename T1>
genesis               481 inline uint256 Hash(const T1 pbegin, const T1 pend)
genesis               482 {
genesis               483     static unsigned char pblank[1];
genesis               484     uint256 hash1;
genesis               485     SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);
genesis               486     uint256 hash2;
genesis               487     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               488     return hash2;
genesis               489 }
genesis               490 
genesis               491 template<typename T1, typename T2>
genesis               492 inline uint256 Hash(const T1 p1begin, const T1 p1end,
genesis               493                     const T2 p2begin, const T2 p2end)
genesis               494 {
genesis               495     static unsigned char pblank[1];
genesis               496     uint256 hash1;
genesis               497     SHA256_CTX ctx;
genesis               498     SHA256_Init(&ctx);
genesis               499     SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
genesis               500     SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
genesis               501     SHA256_Final((unsigned char*)&hash1, &ctx);
genesis               502     uint256 hash2;
genesis               503     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               504     return hash2;
genesis               505 }
genesis               506 
genesis               507 template<typename T1, typename T2, typename T3>
genesis               508 inline uint256 Hash(const T1 p1begin, const T1 p1end,
genesis               509                     const T2 p2begin, const T2 p2end,
genesis               510                     const T3 p3begin, const T3 p3end)
genesis               511 {
genesis               512     static unsigned char pblank[1];
genesis               513     uint256 hash1;
genesis               514     SHA256_CTX ctx;
genesis               515     SHA256_Init(&ctx);
genesis               516     SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
genesis               517     SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
genesis               518     SHA256_Update(&ctx, (p3begin == p3end ? pblank : (unsigned char*)&p3begin[0]), (p3end - p3begin) * sizeof(p3begin[0]));
genesis               519     SHA256_Final((unsigned char*)&hash1, &ctx);
genesis               520     uint256 hash2;
genesis               521     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               522     return hash2;
genesis               523 }
genesis               524 
genesis               525 template<typename T>
genesis               526 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)
genesis               527 {
genesis               528     // Most of the time is spent allocating and deallocating CDataStream's
genesis               529     // buffer.  If this ever needs to be optimized further, make a CStaticStream
genesis               530     // class with its buffer on the stack.
genesis               531     CDataStream ss(nType, nVersion);
genesis               532     ss.reserve(10000);
genesis               533     ss << obj;
genesis               534     return Hash(ss.begin(), ss.end());
genesis               535 }
genesis               536 
genesis               537 inline uint160 Hash160(const std::vector<unsigned char>& vch)
genesis               538 {
genesis               539     uint256 hash1;
genesis               540     SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);
genesis               541     uint160 hash2;
genesis               542     RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               543     return hash2;
genesis               544 }
genesis               545 
genesis               546 
genesis               547 // Median filter over a stream of values
genesis               548 // Returns the median of the last N numbers
genesis               549 template <typename T> class CMedianFilter
genesis               550 {
genesis               551 private:
genesis               552     std::vector<T> vValues;
genesis               553     std::vector<T> vSorted;
genesis               554     int nSize;
genesis               555 public:
genesis               556     CMedianFilter(int size, T initial_value):
genesis               557         nSize(size)
genesis               558     {
genesis               559         vValues.reserve(size);
genesis               560         vValues.push_back(initial_value);
genesis               561         vSorted = vValues;
genesis               562     }
genesis               563     
genesis               564     void input(T value)
genesis               565     {
genesis               566         if(vValues.size() == nSize)
genesis               567         {
genesis               568             vValues.erase(vValues.begin());
genesis               569         }
genesis               570         vValues.push_back(value);
genesis               571 
genesis               572         vSorted.resize(vValues.size());
genesis               573         std::copy(vValues.begin(), vValues.end(), vSorted.begin());
genesis               574         std::sort(vSorted.begin(), vSorted.end());
genesis               575     }
genesis               576 
genesis               577     T median() const
genesis               578     {
genesis               579         int size = vSorted.size();
genesis               580         assert(size>0);
genesis               581         if(size & 1) // Odd number of elements
genesis               582         {
genesis               583             return vSorted[size/2];
genesis               584         }
genesis               585         else // Even number of elements
genesis               586         {
genesis               587             return (vSorted[size/2-1] + vSorted[size/2]) / 2;
genesis               588         }
genesis               589     }
genesis               590 };
genesis               591 
genesis               592 
genesis               593 
genesis               594 
genesis               595 
genesis               596 
genesis               597 
genesis               598 
genesis               599 
genesis               600 
genesis               601 // Note: It turns out we might have been able to use boost::thread
genesis               602 // by using TerminateThread(boost::thread.native_handle(), 0);
genesis               603 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)
genesis               604 {
genesis               605     pthread_t hthread = 0;
genesis               606     int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg);
genesis               607     if (ret != 0)
genesis               608     {
genesis               609         printf("Error: pthread_create() returned %d\n", ret);
genesis               610         return (pthread_t)0;
genesis               611     }
genesis               612     if (!fWantHandle)
genesis               613     {
genesis               614         pthread_detach(hthread);
genesis               615         return (pthread_t)-1;
genesis               616     }
genesis               617     return hthread;
genesis               618 }
genesis               619 
genesis               620 #define THREAD_PRIORITY_LOWEST          PRIO_MAX
genesis               621 #define THREAD_PRIORITY_BELOW_NORMAL    2
genesis               622 #define THREAD_PRIORITY_NORMAL          0
genesis               623 #define THREAD_PRIORITY_ABOVE_NORMAL    0
genesis               624 
genesis               625 inline void SetThreadPriority(int nPriority)
genesis               626 {
genesis               627     // It's unclear if it's even possible to change thread priorities on Linux,
genesis               628     // but we really and truly need it for the generation threads.
genesis               629 #ifdef PRIO_THREAD
genesis               630     setpriority(PRIO_THREAD, 0, nPriority);
genesis               631 #else
genesis               632     setpriority(PRIO_PROCESS, 0, nPriority);
genesis               633 #endif
genesis               634 }
genesis               635 
genesis               636 inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)
genesis               637 {
genesis               638     return (pthread_cancel(hthread) == 0);
genesis               639 }
genesis               640 
genesis               641 inline void ExitThread(size_t nExitCode)
genesis               642 {
genesis               643     pthread_exit((void*)nExitCode);
genesis               644 }
genesis               645 
genesis               646 
genesis               647 
genesis               648 inline bool AffinityBugWorkaround(void(*pfn)(void*))
genesis               649 {
genesis               650     return false;
genesis               651 }
genesis               652 
genesis               653 inline uint32_t ByteReverse(uint32_t value)
genesis               654 {
genesis               655     value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
genesis               656     return (value<<16) | (value>>16);
genesis               657 }
genesis               658 
genesis               659 #endif