case IT_RIGHTOPEN:		if (m_low == high)		{			if (type == IT_CLOSED || type == IT_LEFTOPEN) return true;			else return false;		}		else if (m_high == low)		{			return false;		}		break;	case IT_LEFTOPEN:		if (m_low == high)		{			return false;		}		else if (m_high == low)		{			if (type == IT_CLOSED || type == IT_RIGHTOPEN) return true;			else return false;		}		break;	}	return true;}bool Tools::Interval::containsInterval(const IInterval& i) const{	if (m_high < m_low) throw IllegalStateException("intersectsInterval: high boundary is smaller than low boundary.");	double low = i.getLowerBound();	double high = i.getUpperBound();	IntervalType type = i.getIntervalType();	if (m_low < low && m_high > high) return true;	if (m_low > low || m_high < high) return false;	switch (m_type)	{	case IT_CLOSED:		break;	case IT_OPEN:		if ((m_low == low && m_high == high && type != IT_OPEN) ||			(m_low == low && (type == IT_CLOSED || type == IT_RIGHTOPEN)) ||			(m_high == high && ( type == IT_CLOSED || type == IT_LEFTOPEN))) return false;		break;	case IT_RIGHTOPEN:		if (m_high == high && (type == IT_CLOSED || type == IT_LEFTOPEN))return false;		break;	case IT_LEFTOPEN:		if (m_low == low && (type == IT_CLOSED || type == IT_RIGHTOPEN))return false;		break;	}	return true;}Tools::IntervalType Tools::Interval::getIntervalType() const{	return m_type;}void Tools::Random::initialize(){	static bool bCalled = false;	if (bCalled == false)	{		srand48(time(NULL));		bCalled = true;	}}long Tools::Random::nextUniformLong(long low, long high){	initialize();	return (long) floor(((double) low + ((double) (high - low)) * drand48()));}int Tools::Random::nextUniformInt(int low, int high){	initialize();	return (int) floor(((double) low + ((double) (high - low)) * drand48()));}double Tools::Random::nextUniformDouble(double low, double high){	initialize();	return (low + ((high - low) * drand48()));}double Tools::Random::nextUniformDouble(){	initialize();	return drand48();}// mean 0.0, standard deviation 1.0double Tools::Random::nextGaussianDouble(){	initialize();	static bool haveNextNextGaussian = false;	static double nextNextGaussian;	if (haveNextNextGaussian)	{		haveNextNextGaussian = false;		return nextNextGaussian;	}	else	{		double v1, v2, s;		do		{			v1 = 2 * drand48() - 1;   // between -1.0 and 1.0			v2 = 2 * drand48() - 1;   // between -1.0 and 1.0			s = v1 * v1 + v2 * v2;		}		while (s >= 1 || s == 0);		double multiplier = std::sqrt(-2 * std::log(s)/s);		nextNextGaussian = v2 * multiplier;		haveNextNextGaussian = true;		return v1 * multiplier;	}}double Tools::Random::nextGaussianDouble(double m, double std){	initialize(); 	return m + (std * nextGaussianDouble());}double Tools::Random::nextZipfDouble(double low, double high, double p){	double x;	int i;	double r, HsubV, sum;	int V = 100;	/* calculate the V-th harmonic number HsubV. WARNING: V>1 */	HsubV = 0.0;	for(i = 1; i <= V; i++) HsubV += 1.0 / pow((double) i, p);	r = nextUniformDouble() * HsubV;	sum = 1.0; i=1;	while(sum < r)	{		i++;		sum += 1.0/ pow((double)i, p);	}	/* i follows Zipf distribution and lies between 1 and V */	/* x lies between 0. and 1. and then between low and high */	x = ((double) i - 1.0) / ((double) V - 1.0);	x = (high - low) * x + low;	return x;}bool Tools::Random::flipCoin(){	if (nextUniformDouble() >= 0.5) return true;	return false;}Tools::ResourceUsage::ResourceUsage(){	reset();}void Tools::ResourceUsage::start(){	struct timezone dummy;	if (getrusage(RUSAGE_SELF, &m_tmpRU) != 0) throw IllegalStateException("Tools::ResourceUsage::start: getrusage failed.");;  	if (gettimeofday(&m_tmpTV, &dummy) != 0) throw IllegalStateException("Tools::ResourceUsage::start: gettimeofday failed.");;}void Tools::ResourceUsage::stop(){	struct timezone dummy;  	struct timeval dif;	struct rusage ru;
  	struct timeval tv;	if (getrusage(RUSAGE_SELF, &ru) != 0) throw IllegalStateException("Tools::ResourceUsage::stop: getrusage failed.");	if (gettimeofday(&tv, &dummy) != 0) throw IllegalStateException("Tools::ResourceUsage::stop: gettimeofday failed.");	// total_time	subtractTimeval(dif, tv, m_tmpTV);	addTimeval(m_totalTime, dif);	// system_time	subtractTimeval(dif, ru.ru_stime, m_tmpRU.ru_stime);	addTimeval(m_systemTime, dif);	// user_time	subtractTimeval(dif, ru.ru_utime, m_tmpRU.ru_utime);  	addTimeval(m_userTime, dif);	// readIO, writeIOs	m_readIO += ru.ru_inblock - m_tmpRU.ru_inblock;	m_writeIO += ru.ru_oublock - m_tmpRU.ru_oublock;	// maximum resident set size	m_peakMemory = std::max(m_peakMemory, ru.ru_maxrss);	// page faults	m_pageFaults += ru.ru_majflt - m_tmpRU.ru_majflt;}void Tools::ResourceUsage::reset(){	m_pageFaults = 0;	m_readIO = 0;	m_writeIO = 0;	m_peakMemory = 0;	m_totalTime.tv_sec = 0;	m_totalTime.tv_usec = 0;	m_userTime.tv_sec = 0;	m_userTime.tv_usec = 0;	m_systemTime.tv_sec = 0;	m_systemTime.tv_usec = 0;}double Tools::ResourceUsage::combineTime(const struct timeval& t){	return static_cast<double>(t.tv_sec) + static_cast<double>(t.tv_usec) / 1000000.0;}void Tools::ResourceUsage::addTimeval(struct timeval& result, const struct timeval& a){	result.tv_sec += a.tv_sec;	result.tv_usec += a.tv_usec;	if (result.tv_usec > 1000000)	{		long div = result.tv_usec / 1000000;		result.tv_sec += div;		result.tv_usec -= div * 1000000;	}}void Tools::ResourceUsage::subtractTimeval(struct timeval& result, const struct timeval& a, const struct timeval& b){	result.tv_sec = a.tv_sec - b.tv_sec;	result.tv_usec = a.tv_usec - b.tv_usec;	if (result.tv_usec < 0)	{		result.tv_sec -= 1;    	result.tv_usec += 1000000;    }}double Tools::ResourceUsage::getTotalTime(){	return combineTime(m_totalTime);}double Tools::ResourceUsage::getUserTime(){	return combineTime(m_userTime);}double Tools::ResourceUsage::getSystemTime(){	return combineTime(m_systemTime);}long Tools::ResourceUsage::getPageFaults(){	return m_pageFaults;}long Tools::ResourceUsage::getReadIO(){	return m_readIO;}long Tools::ResourceUsage::getWriteIO(){	return m_writeIO;}long Tools::ResourceUsage::getPeakMemoryUsage(){	return m_peakMemory;}#ifdef PTHREADSTools::SharedLock::SharedLock(pthread_rwlock_t* pLock)	: m_pLock(pLock){	pthread_rwlock_rdlock(m_pLock);}Tools::SharedLock::~SharedLock(){	pthread_rwlock_unlock(m_pLock);}Tools::ExclusiveLock::ExclusiveLock(pthread_rwlock_t* pLock)	: m_pLock(pLock){	pthread_rwlock_wrlock(m_pLock);}Tools::ExclusiveLock::~ExclusiveLock(){	pthread_rwlock_unlock(m_pLock);}#endifTools::StringTokenizer::StringTokenizer(const std::string& str, const std::string& delimiters)	: m_index(0){    // Skip delimiters at beginning.
    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    std::string::size_type pos = str.find_first_of(delimiters, lastPos);

    while (std::string::npos != pos || std::string::npos != lastPos)
    {
        // Found a token, add it to the vector.
        m_token.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }}std::string Tools::StringTokenizer::getNextToken(){	return m_token.at(m_index++);}bool Tools::StringTokenizer::hasMoreTokens(){	return (m_index < m_token.size());}
void Tools::StringTokenizer::reset(){	m_index = 0;}
std::string Tools::trimLeft(const std::string& source, const std::string& t)
{
    std::string str = source;
    return str.erase(0, source.find_first_not_of(t));
}

std::string Tools::trimRight(const std::string& source, const std::string& t)
{
    std::string str = source;
    return str.erase(str.find_last_not_of(t) + 1);
}

std::string Tools::trim(const std::string& source, const std::string& t)
{
    std::string str = source;
    return trimLeft(trimRight(str, t), t);
}

char Tools::toLower(char c)
{
    return std::tolower(c);
}

char Tools::toUpper(char c)
{
    return std::toupper(c);
}

std::string Tools::toUpperCase(const std::string& s)
{
    std::string t = s;
    transform(t.begin(), t.end(), t.begin(), Tools::toUpper);
    return t;
}
std::string Tools::toLowerCase(const std::string& s)
{
    std::string t = s;
    transform(t.begin(), t.end(), t.begin(), Tools::toLower);
    return t;
}
std::ostream& Tools::operator<<(std::ostream& os, const Tools::PropertySet& p){	for (std::map<std::string, Variant>::const_iterator it = p.m_propertySet.begin(); it != p.m_propertySet.end(); it++)	{		switch ((*it).second.m_varType)		{		case VT_LONG:			os << (*it).first << ": " << (*it).second.m_val.lVal << ", ";			break;		case VT_BYTE:			os << (*it).first << ": " << (*it).second.m_val.bVal << ", ";			break;		case VT_SHORT:			os << (*it).first << ": " << (*it).second.m_val.iVal << ", ";			break;		case VT_FLOAT:			os << (*it).first << ": " << (*it).second.m_val.fltVal << ", ";			break;		case VT_DOUBLE:			os << (*it).first << ": " << (*it).second.m_val.dblVal << ", ";			break;		case VT_CHAR:			os << (*it).first << ": " << (*it).second.m_val.cVal << ", ";			break;		case VT_USHORT:			os << (*it).first << ": " << (*it).second.m_val.uiVal << ", ";			break;		case VT_ULONG:			os << (*it).first << ": " << (*it).second.m_val.ulVal << ", ";			break;		case VT_INT:			os << (*it).first << ": " << (*it).second.m_val.intVal << ", ";			break;		case VT_UINT:			os << (*it).first << ": " << (*it).second.m_val.uintVal << ", ";			break;		case VT_BOOL:			os << (*it).first << ": " << (*it).second.m_val.blVal << ", ";			break;		case VT_PCHAR:			os << (*it).first << ": " << (*it).second.m_val.pcVal << ", ";			break;		case VT_PVOID:			os << (*it).first << ": ?" << ", ";			break;		case VT_EMPTY:			os << (*it).first << ": empty" << ", ";			break;		default:			os << (*it).first << ": unknown" << ", ";		}	}	return os;}std::ostream& Tools::operator<<(std::ostream& os, const Tools::Interval& iv){	os << "Type: " << iv.m_type << ", Low: " << iv.m_low << ", High: " << iv.m_high;	return os;}