tools.cc

tools.03b.zip

// Tools Library
//
// Copyright (C) 2004  Navel Ltd.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// Contact information:
//  Mailing address:
//    Marios Hadjieleftheriou
//    University of California, Riverside
//    Department of Computer Science
//    Surge Building, Room 310
//    Riverside, CA 92521
//
//  Email:
//    [e-mail]

#include <Tools.h>
#include "ExternalSort.h"

const std::string VERSION = "0.3b";
const std::string DATE = "06 June 2004";

Tools::IndexOutOfBoundsException::IndexOutOfBoundsException(int i)
{
	std::ostringstream s;
	s << "Invalid index " << i;
	m_error = s.str();
}

std::string Tools::IndexOutOfBoundsException::what()
{
	return "IndexOutOfBoundsException: " + m_error;
}

Tools::IllegalArgumentException::IllegalArgumentException(std::string s) : m_error(s)
{
}

std::string Tools::IllegalArgumentException::what()
{
	return "IllegalArgumentException: " + m_error;
}

Tools::IllegalStateException::IllegalStateException(std::string s) : m_error(s)
{
}

std::string Tools::IllegalStateException::what()
{
	return "IllegalStateException: " + m_error + "\nPlease contact " + EMAIL;
}

Tools::EndOfStreamException::EndOfStreamException(std::string s) : m_error(s)
{
}

std::string Tools::EndOfStreamException::what()
{
	return "EndOfStreamException: " + m_error;
}

Tools::ResourceLockedException::ResourceLockedException(std::string s) : m_error(s)
{
}

std::string Tools::ResourceLockedException::what()
{
	return "ResourceLockedException: " + m_error;
}

Tools::InvalidPageException::InvalidPageException(long id)
{
	std::ostringstream s;
	s << "Unknown page id " << id;
	m_error = s.str();
}

std::string Tools::InvalidPageException::what()
{
	return "InvalidPageException: " + m_error;
}

Tools::NotSupportedException::NotSupportedException(std::string s) : m_error(s)
{
}

std::string Tools::NotSupportedException::what()
{
	return "NotSupportedException: " + m_error;
}

Tools::ParseErrorException::ParseErrorException(std::string s) : m_error(s)
{
}

std::string Tools::ParseErrorException::what()
{
	return "ParseErrorException: " + m_error;
}

Tools::Variant::Variant() : m_varType(VT_EMPTY)
{
}

unsigned long Tools::PropertySet::getByteArraySize()
{
	unsigned long size = sizeof(unsigned long);

	for (std::map<std::string, Variant>::iterator it = m_propertySet.begin(); it != m_propertySet.end(); it++)
	{
		switch ((*it).second.m_varType)
		{
		case VT_LONG:
			size += sizeof(long);
			break;
		case VT_BYTE:
			size += sizeof(byte);
			break;
		case VT_SHORT:
			size += sizeof(short);
			break;
		case VT_FLOAT:
			size += sizeof(float);
			break;
		case VT_DOUBLE:
			size += sizeof(double);
			break;
		case VT_CHAR:
			size += sizeof(char);
			break;
		case VT_USHORT:
			size += sizeof(unsigned short);
			break;
		case VT_ULONG:
			size += sizeof(unsigned long);
			break;
		case VT_INT:
			size += sizeof(int);
			break;
		case VT_UINT:
			size += sizeof(unsigned int);
			break;
		case VT_BOOL:
			size += sizeof(byte);
			break;
		default:
			throw NotSupportedException("Cannot serialize a variant of this type.");
		}
		size += (*it).first.size() + sizeof(unsigned long) + sizeof(VariantType);
	}

	return size;
}

unsigned long Tools::PropertySet::loadFromByteArray(byte* const data)
{
	byte* ptr = data;
	unsigned long numberOfProperties;
	memcpy(&numberOfProperties, ptr, sizeof(unsigned long));
	ptr += sizeof(unsigned long);

	unsigned long strSize;
	char* str;
	Variant v;

	for (unsigned long cIndex = 0; cIndex < numberOfProperties; cIndex++)
	{
		memcpy(&strSize, ptr, sizeof(unsigned long));
		ptr += sizeof(unsigned long);
		str = new char[strSize + 1]; str[strSize] = 0;
		memcpy(str, ptr, strSize);
		ptr += strSize;
		memcpy(&(v.m_varType), ptr, sizeof(VariantType));
		ptr += sizeof(VariantType);

		switch (v.m_varType)
		{
		case VT_LONG:
			long l;
			memcpy(&l, ptr, sizeof(long));
			ptr += sizeof(long);
			v.m_val.lVal = l;
			break;
		case VT_BYTE:
			byte b;
			memcpy(&b, ptr, sizeof(byte));
			ptr += sizeof(byte);
			v.m_val.bVal = b;
			break;
		case VT_SHORT:
			short s;
			memcpy(&s, ptr, sizeof(short));
			ptr += sizeof(short);
			v.m_val.iVal = s;
			break;
		case VT_FLOAT:
			float f;
			memcpy(&f, ptr, sizeof(float));
			ptr += sizeof(float);
			v.m_val.fltVal = f;
			break;
		case VT_DOUBLE:
			double d;
			memcpy(&d, ptr, sizeof(double));
			ptr += sizeof(double);
			v.m_val.dblVal = d;
			break;
		case VT_CHAR:
			char c;
			memcpy(&c, ptr, sizeof(char));
			ptr += sizeof(char);
			v.m_val.cVal = c;
			break;
		case VT_USHORT:
			unsigned short us;
			memcpy(&us, ptr, sizeof(unsigned short));
			ptr += sizeof(unsigned short);
			v.m_val.uiVal = us;
			break;
		case VT_ULONG:
			unsigned long ul;
			memcpy(&ul, ptr, sizeof(unsigned long));
			ptr += sizeof(unsigned long);
			v.m_val.ulVal = ul;
			break;
		case VT_INT:
			int i;
			memcpy(&i, ptr, sizeof(int));
			ptr += sizeof(int);
			v.m_val.intVal = i;
			break;
		case VT_UINT:
			unsigned int ui;
			memcpy(&ui, ptr, sizeof(unsigned int));
			ptr += sizeof(unsigned int);
			v.m_val.uintVal = ui;
			break;
		case VT_BOOL:
			byte bl;
			memcpy(&bl, ptr, sizeof(byte));
			ptr += sizeof(byte);
			v.m_val.blVal = static_cast<bool>(bl);
			break;
		default:
			throw NotSupportedException("Cannot serialize a variant of this type.");
		}
		m_propertySet.insert(std::pair<std::string, Variant>(std::string(str), v));
		delete[] str;
	}

	return getByteArraySize();
}

void Tools::PropertySet::storeToByteArray(unsigned long& len, byte** data)
{
	len = getByteArraySize();
	*data = new byte[len];

	byte* ptr = *data;

	unsigned long numberOfProperties = m_propertySet.size();
	memcpy(ptr, &numberOfProperties, sizeof(unsigned long));
	ptr += sizeof(unsigned long);

	for (std::map<std::string, Variant>::iterator it = m_propertySet.begin(); it != m_propertySet.end(); it++)
	{
		unsigned long strSize = (*it).first.size();
		memcpy(ptr, &strSize, sizeof(unsigned long));
		ptr += sizeof(unsigned long);
		memcpy(ptr, (*it).first.c_str(), strSize);
		ptr += strSize;
		memcpy(ptr, &((*it).second.m_varType), sizeof(VariantType));
		ptr += sizeof(VariantType);

		switch ((*it).second.m_varType)
		{
		case VT_LONG:
			memcpy(ptr, &((*it).second.m_val.lVal), sizeof(long));
			ptr += sizeof(long);
			break;
		case VT_BYTE:
			memcpy(ptr, &((*it).second.m_val.bVal), sizeof(byte));
			ptr += sizeof(byte);
			break;
		case VT_SHORT:
			memcpy(ptr, &((*it).second.m_val.iVal), sizeof(short));
			ptr += sizeof(short);
			break;
		case VT_FLOAT:
			memcpy(ptr, &((*it).second.m_val.fltVal), sizeof(float));
			ptr += sizeof(float);
			break;
		case VT_DOUBLE:
			memcpy(ptr, &((*it).second.m_val.dblVal), sizeof(double));
			ptr += sizeof(double);
			break;
		case VT_CHAR:
			memcpy(ptr, &((*it).second.m_val.cVal), sizeof(char));
			ptr += sizeof(char);
			break;
		case VT_USHORT:
			memcpy(ptr, &((*it).second.m_val.uiVal), sizeof(unsigned short));
			ptr += sizeof(unsigned short);
			break;
		case VT_ULONG:
			memcpy(ptr, &((*it).second.m_val.ulVal), sizeof(unsigned long));
			ptr += sizeof(unsigned long);
			break;
		case VT_INT:
			memcpy(ptr, &((*it).second.m_val.intVal), sizeof(int));
			ptr += sizeof(int);
			break;
		case VT_UINT:
			memcpy(ptr, &((*it).second.m_val.uintVal), sizeof(unsigned int));
			ptr += sizeof(unsigned int);
			break;
		case VT_BOOL:
			byte bl;
			bl = (*it).second.m_val.blVal;
			memcpy(ptr, &bl, sizeof(byte));
			ptr += sizeof(byte);
			break;
		default:
			throw NotSupportedException("Cannot serialize a variant of this type.");
		}
	}
}

Tools::Variant Tools::PropertySet::getProperty(std::string property)
{
	std::map<std::string, Variant>::iterator it = m_propertySet.find(property);
	if (it != m_propertySet.end()) return (*it).second;
	else return Variant();
}

void Tools::PropertySet::setProperty(std::string property, Variant& v)
{
	m_propertySet.insert(std::pair<std::string, Variant>(property, v));
}

void Tools::PropertySet::removeProperty(std::string property)
{
	std::map<std::string, Variant>::iterator it = m_propertySet.find(property);
	if (it != m_propertySet.end()) m_propertySet.erase(it);
}

Tools::IObjectStream* Tools::externalSort(IObjectStream& source, unsigned long bufferSize)
{
	return new ExternalSort(source, bufferSize);

}

Tools::IObjectStream* Tools::externalSort(IObjectStream& source, IObjectComparator& comp, unsigned long bufferSize)
{
	return new ExternalSort(source, comp, bufferSize);
}

Tools::Interval::Interval() : m_type(IT_RIGHTOPEN), m_low(0.0), m_high(0.0)
{
}

Tools::Interval::Interval(IntervalType t, double l, double h) : m_type(t), m_low(l), m_high(h)
{
	assert(l < h);
}

Tools::Interval::Interval(double l, double h) : m_type(IT_RIGHTOPEN), m_low(l), m_high(h)
{
	assert(l < h);
}

Tools::Interval::Interval(const Interval& iv)
{
	m_low = iv.m_low;
	m_high = iv.m_high;
	m_type = iv.m_type;
}

Tools::IInterval& Tools::Interval::operator=(const IInterval& iv)
{
	if (this != &iv)
	{
		m_low = iv.getLowerBound();
		m_high = iv.getUpperBound();
		m_type = iv.getIntervalType();
	}

	return *this;
}

Tools::Interval& Tools::Interval::operator=(const Interval& iv)
{
	*this = *(static_cast<const IInterval*>(&iv));
	return *this;
}

double Tools::Interval::getLowerBound() const
{
	return m_low;
}

double Tools::Interval::getUpperBound() const
{
	return m_high;
}

void Tools::Interval::setBounds(double l, double h)
{
	assert(l <= h);

	m_low = l;
	m_high = h;
}

bool Tools::Interval::intersectsInterval(const IInterval& i) const
{
	return intersectsInterval(i.getIntervalType(), i.getLowerBound(), i.getUpperBound());
}

bool Tools::Interval::intersectsInterval(IntervalType type, const double low, const double high) const
{
	if (m_high < m_low) throw IllegalStateException("intersectsInterval: high boundary is smaller than low boundary.");

	if (m_low > high || m_high < low) return false;
	if ((m_low > low && m_low < high) || (m_high > low && m_high < high)) return true;

	switch (m_type)
	{
	case IT_CLOSED:
		if (m_low == high)
		{
			if (type == IT_CLOSED || type == IT_LEFTOPEN) return true;
			else return false;
		}
		else if (m_high == low)
		{
			if (type == IT_CLOSED || type == IT_RIGHTOPEN) return true;
			else return false;
		}
		break;
	case IT_OPEN:
		if (m_low == high || m_high == low) return false;
		break;