tools.cc

tools.03b.zip

	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.0
double 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 PTHREADS
Tools::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);
}
#endif

Tools::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;
}