290 lines
13 KiB
C++
290 lines
13 KiB
C++
/*
|
|
* Copyright 2011, 2014 Range Networks, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* This software is distributed under multiple licenses;
|
|
* see the COPYING file in the main directory for licensing
|
|
* information for this specific distribution.
|
|
*
|
|
* This use of this software may be subject to additional restrictions.
|
|
* See the LEGAL file in the main directory for details.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
#ifndef _UTILS_H
|
|
#define _UTILS_H
|
|
#include <stdint.h>
|
|
#include <stdarg.h>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <string.h>
|
|
#include <math.h> // for sqrtf
|
|
#include <typeinfo>
|
|
#include "Logger.h"
|
|
|
|
|
|
namespace Utils {
|
|
using namespace std;
|
|
|
|
extern double timef(); // high resolution time
|
|
// We dont use a default arg here timestr(unsigned fieldwidth=12) because g++ complains about duplicate decl in Logger.h
|
|
extern const std::string timestr(); // A timestamp to print in messages.
|
|
extern const std::string timestr(unsigned fieldwidth, bool addDate = false); // A timestamp to print in messages.
|
|
extern void sleepf(double howlong); // high resolution sleep
|
|
extern int gcd(int x, int y);
|
|
|
|
string format(const char *fmt, ...) __attribute__((format (printf,1,2)));
|
|
|
|
// format1 used to prevent C++ confusion over what function to call here.
|
|
string format1(const char *fmt, ...) __attribute__((format (printf,1,2)));
|
|
// We have to enumerate the cross product of argument types here. This is fixed in C++11.
|
|
inline string format(const char *fmt, string s1) {
|
|
return format1(fmt,s1.c_str());
|
|
}
|
|
inline string format(const char *fmt, string s1, string s2) {
|
|
return format1(fmt,s1.c_str(),s2.c_str());
|
|
}
|
|
inline string format(const char *fmt, string s1, string s2, string s3) {
|
|
return format1(fmt,s1.c_str(),s2.c_str(),s3.c_str());
|
|
}
|
|
inline string format(const char *fmt, string s1, string s2, string s3, string s4) {
|
|
return format1(fmt,s1.c_str(),s2.c_str(),s3.c_str(),s4.c_str());
|
|
}
|
|
inline string format(const char *fmt, string s1, int i1) {
|
|
return format1(fmt,s1.c_str(),i1);
|
|
}
|
|
inline string format(const char *fmt, int i1, string s1) {
|
|
return format1(fmt,i1,s1.c_str());
|
|
}
|
|
inline string format(const char *fmt, string s1, string s2, int i1) {
|
|
return format1(fmt,s1.c_str(),s2.c_str(),i1);
|
|
}
|
|
inline string format(const char *fmt, string s1, string s2, int i1, int i2) {
|
|
return format1(fmt,s1.c_str(),s2.c_str(),i1,i2);
|
|
}
|
|
|
|
int myscanf(const char *str, const char *fmt, string *s1);
|
|
int myscanf(const char *str, const char *fmt, string *s1, string *s2);
|
|
int myscanf(const char *str, const char *fmt, string *s1, string *s2, string *s3);
|
|
int myscanf(const char *str, const char *fmt, string *s1, string *s2, string *s3, string *s4);
|
|
|
|
int cstrSplit(char *in, char **pargv,int maxargc, const char *splitchars=NULL);
|
|
char *cstrGetArg(const char *in, int nth, unsigned *length);
|
|
|
|
// For classes with a text() function, provide a function to return a String,
|
|
// and also a standard << stream function that takes a pointer to the object.
|
|
// We dont provide the function that takes a reference to the object
|
|
// because it is too highly overloaded and generally doesnt work.
|
|
class Text2Str {
|
|
public:
|
|
virtual void text(std::ostream &os) const = 0;
|
|
std::string str() const;
|
|
};
|
|
std::ostream& operator<<(std::ostream& os, const Text2Str *val);
|
|
|
|
#if 0
|
|
// Generic Activity Timer. Lots of controls to make everybody happy.
|
|
class ATimer {
|
|
double mStart;
|
|
//bool mActive;
|
|
double mLimitTime;
|
|
public:
|
|
ATimer() : mStart(0), mLimitTime(0) { }
|
|
ATimer(double wLimitTime) : mStart(0), mLimitTime(wLimitTime) { }
|
|
void start() { mStart=timef(); }
|
|
void stop() { mStart=0; }
|
|
bool active() { return !!mStart; }
|
|
double elapsed() { return timef() - mStart; }
|
|
bool expired() { return elapsed() > mLimitTime; }
|
|
};
|
|
#endif
|
|
|
|
|
|
struct BitSet {
|
|
unsigned mBits;
|
|
void setBit(unsigned whichbit) { mBits |= 1<<whichbit; }
|
|
void clearBit(unsigned whichbit) { mBits &= ~(1<<whichbit); }
|
|
unsigned getBit(unsigned whichbit) const { return mBits & (1<<whichbit); }
|
|
bool isSet(unsigned whichbit) const { return mBits & (1<<whichbit); }
|
|
unsigned bits() const { return mBits; }
|
|
operator int(void) const { return mBits; }
|
|
BitSet() { mBits = 0; }
|
|
};
|
|
|
|
// Store current, min, max and compute running average and standard deviation.
|
|
template<class Type> struct Statistic {
|
|
Type mCurrent, mMin, mMax; // min,max optional initialization so you can print before adding any values.
|
|
unsigned mCnt;
|
|
double mSum;
|
|
//double mSum2; // sum of squares.
|
|
// (Type) cast needed in case Type is an enum, stupid language.
|
|
Statistic() : mCurrent((Type)0), mMin((Type)0), mMax((Type)0), mCnt(0), mSum(0) /*,mSum2(0)*/ {}
|
|
// Set the current value and add a statisical point.
|
|
void addPoint(Type val) {
|
|
mCurrent = val;
|
|
if (mCnt == 0 || val < mMin) {mMin = val;}
|
|
if (mCnt == 0 || val > mMax) {mMax = val;}
|
|
mCnt++;
|
|
mSum += val;
|
|
//mSum2 += val * val;
|
|
}
|
|
Type getCurrent() const { // Return current value.
|
|
return mCnt ? mCurrent : 0;
|
|
}
|
|
double getAvg() const { // Return average.
|
|
return mCnt==0 ? 0 : mSum/mCnt;
|
|
};
|
|
//float getSD() const { // Return standard deviation. Use low precision square root function.
|
|
// return mCnt==0 ? 0 : sqrtf(mCnt * mSum2 - mSum*mSum) / mCnt;
|
|
//}
|
|
|
|
void text(std::ostream &os) const { // Print everything in parens.
|
|
os << "("<<mCurrent;
|
|
if (mMin != mMax) { // No point in printing all this stuff if min == max.
|
|
os <<LOGVAR2("min",mMin)<<LOGVAR2("max",mMax)<<LOGVAR2("avg",getAvg());
|
|
if (mCnt <= 999999) {
|
|
os <<LOGVAR2("N",mCnt);
|
|
} else { // Shorten this up:
|
|
char buf[10], *ep;
|
|
sprintf(buf,"%.3g",round(mCnt));
|
|
if ((ep = strchr(buf,'e')) && ep[1] == '+') { strcpy(ep+1,ep+2); }
|
|
os << LOGVAR2("N",buf);
|
|
}
|
|
// os<<LOGVAR2("sd",getSD()) standard deviation not interesting
|
|
}
|
|
os << ")";
|
|
// " min="<<mMin <<" max="<<mMax <<format(" avg=%4g sd=%3g)",getAvg(),getSD());
|
|
}
|
|
// Not sure if this works:
|
|
//std::string statStr() const {
|
|
// return (std::string)mCurrent + " min=" + (std::string) mMin +" max="+(string)mMax+ format(" avg=%4g sd=%3g",getAvg(),getSD());
|
|
//}
|
|
};
|
|
|
|
// This I/O mechanism is so dumb:
|
|
std::ostream& operator<<(std::ostream& os, const Statistic<int> &stat);
|
|
std::ostream& operator<<(std::ostream& os, const Statistic<unsigned> &stat);
|
|
std::ostream& operator<<(std::ostream& os, const Statistic<float> &stat);
|
|
std::ostream& operator<<(std::ostream& os, const Statistic<double> &stat);
|
|
|
|
|
|
// Yes, they botched and left this out:
|
|
std::ostream& operator<<(std::ostream& os, std::ostringstream& ss);
|
|
|
|
std::ostream &osprintf(std::ostream &os, const char *fmt, ...) __attribute__((format (printf,2,3)));
|
|
|
|
std::string replaceAll(const std::string input, const std::string search, const std::string replace);
|
|
|
|
vector<string>& stringSplit(vector<string> &result,const char *input);
|
|
typedef vector<vector<string> > prettyTable_t;
|
|
void printPrettyTable(prettyTable_t &tab, ostream&os, bool tabSeparated = false);
|
|
|
|
// The need for this is eliminated in C++11.
|
|
string stringcat(string a, string b);
|
|
string stringcat(string a, string b, string c);
|
|
string stringcat(string a, string b, string c, string d);
|
|
string stringcat(string a, string b, string c, string d, string e);
|
|
string stringcat(string a, string b, string c, string d, string e, string f);
|
|
string stringcat(string a, string b, string c, string d, string e, string f, string g);
|
|
|
|
extern void stringToUint(string strRAND, uint64_t *hRAND, uint64_t *lRAND);
|
|
extern string uintToString(uint64_t h, uint64_t l);
|
|
extern string uintToString(uint32_t x);
|
|
|
|
//template <class Type> class RefCntPointer;
|
|
// The class is created with a RefCnt of 0. The caller may assign the constructed result to a pointer
|
|
// of type RefCntPointer. If so, then when the last RefCntPointer is freed, this struct is too.
|
|
class RefCntBase {
|
|
template <class Type> friend class RefCntPointer;
|
|
mutable Mutex mRefMutex;
|
|
mutable short mRefCnt; // signed, not unsigned!
|
|
int setRefCnt(int val) { return mRefCnt = val; }
|
|
// The semantics of reference counting mean you cannot copy an object that has reference counts;
|
|
// they are only manipulated by pointers. This constructor is private, which makes C++ whine if you do this.
|
|
// Actually, you could copy it, if the refcnt in the new object were 0 and the pointer was assigned to a RefCntPointer.
|
|
RefCntBase(RefCntBase &) { assert(0); }
|
|
RefCntBase(const RefCntBase &) { assert(0); }
|
|
RefCntBase operator=(RefCntBase &) {assert(0); mRefCnt = 0; return *this; }
|
|
// These are not 'const' but wonderful C++ requires us to declare them const so we can use a const pointer as the RefCntPointer target,
|
|
// then add 'mutable' to everything. What a botched up language.
|
|
int decRefCnt() const; // Only RefCntPointer is permitted to use incRefCnt and decRefCnt.
|
|
void incRefCnt() const;
|
|
public:
|
|
virtual ~RefCntBase();
|
|
RefCntBase() : mRefCnt(0) {}
|
|
int getRefCnt() const { return mRefCnt; }
|
|
};
|
|
|
|
// This is basically the same as a C++11 shared_ptr, but we cannot use C++ 11 yet.
|
|
// The basic idea is that once you put an object into a RefCntPointer, then destruction of that
|
|
// object is controlled by and assured by RefCntPointer using reference counts; when the last
|
|
// RefCntPointer referring to the object is destroyed, the object is too.
|
|
// You can use RefCntPointer<object> similarly to an object* for most data-access purposes.
|
|
// The auto-destruction should be optional - there should be a version that just maintains reference counts for you.
|
|
// Semantics:
|
|
// SomeDescendentOfRefCntBase foo;
|
|
// RefCntPointer<SomeDescendentOfRefCntBase> ptrToFoo;
|
|
// ptrToFoo = &foo; // increment the reference count of foo.
|
|
// ... ptrToFoo->... // Normal code using ptrToFoo as a (SomeDescendentOfRefCntBase*)
|
|
// ptrToFoo = 0; // release pointer and decrement reference count of foo.
|
|
// ptrToFoo.free(); // A better way to release it.
|
|
template<class Type> // Type must be a descendent of RefCntBase.
|
|
class RefCntPointer {
|
|
Type *rcPointer;
|
|
void rcInc() { if (rcPointer) rcPointer->incRefCnt(); }
|
|
void rcDec() {
|
|
if (rcPointer) if (rcPointer->decRefCnt() <= 0) { rcPointer = NULL; };
|
|
}
|
|
public:
|
|
RefCntPointer() : rcPointer(NULL) { }
|
|
RefCntPointer(const RefCntPointer &other) { rcPointer = other.rcPointer; rcInc(); }
|
|
RefCntPointer(RefCntPointer &other) { rcPointer = other.rcPointer; rcInc(); }
|
|
RefCntPointer(Type*other) { rcPointer = other; rcInc(); }
|
|
// (pat) Making this virtual ~RefCntPointer makes ~MMContext crash, dont know why.
|
|
// (pat) Update: lets try making it virtual again; it should work, but no one derives off RefCntPointer so I dont know why it crashes..
|
|
~RefCntPointer() {
|
|
if (rcPointer) { LOG(DEBUG) <<" rcPointer="<<((void*)rcPointer) <<" refcnt="<<(rcPointer?rcPointer->getRefCnt():0); }
|
|
rcDec();
|
|
rcPointer = NULL; // should be redundant
|
|
}
|
|
Type* self() const { return rcPointer; }
|
|
// The operator=(Type*) is called if the argument is NULL, so we dont need int.
|
|
//Type* operator=(int value) { assert(value == 0); rcDec(); rcPointer = 0; return rcPointer; }
|
|
// We increment before decrement if possible so that a = a; does not crash.
|
|
RefCntPointer<Type>& operator=(RefCntPointer other) { other.rcInc(); rcDec(); rcPointer = other.rcPointer; return *this; }
|
|
// The old is the previous value of this pointer. We do not decrement the refcnt in the other that we are taking charge of.
|
|
RefCntPointer<Type>& operator=(Type* other) { Type *old = rcPointer; rcPointer = other; rcInc(); if (old) {old->decRefCnt();} return *this; }
|
|
bool operator==(const RefCntPointer &other) const { return rcPointer == other.rcPointer; }
|
|
bool operator==(const Type* other) const { return rcPointer == other; }
|
|
bool operator!=(const RefCntPointer &other) const { return rcPointer != other.rcPointer; }
|
|
bool operator!=(const Type* other) const { return rcPointer != other; }
|
|
Type* operator->() const { return rcPointer; }
|
|
Type& operator*() const { return *rcPointer; }
|
|
// This auto-conversion causes gcc warning messages, which are of no import, but to avoid them I now use self() everywhere instead.
|
|
//operator Type*() const { return rcPointer; }
|
|
// free is a synonym for *this = NULL; but it is a better comment in the code what is happening. RefCntBase is only freed if this was the last pointer to it.
|
|
void free() {
|
|
int refcnt = rcPointer ? rcPointer->getRefCnt() : 0;
|
|
rcDec();
|
|
if (refcnt > 1) { LOG(DEBUG)<<"RefCntPointer "<<(void*)rcPointer<<" refcnt before="<<refcnt<< " did not free structure."; }
|
|
else { LOG(DEBUG)<<"RefCntPointer "<<(void*)rcPointer<<" refcnt before="<<refcnt; }
|
|
rcPointer = NULL;
|
|
}
|
|
bool isNULL() const { return self() == NULL; }
|
|
};
|
|
|
|
extern string firstlines(string msgstr, int n=2);
|
|
|
|
extern std::string rn_backtrace();
|
|
extern string decodeToString(const char *buf, unsigned buflen, string encodingArg, string &errorMessage);
|
|
extern string encodeToString(const char *data, unsigned datalen, string encodingArg, string &errorMessage);
|
|
|
|
}; // namespace
|
|
|
|
using namespace Utils;
|
|
|
|
#endif
|