ump-0.8.6/src/vector.h

/*
 *  Vector - A template vector-class
 *  Copyright (c) 2005 by Mattias Hultgren <mattias_hultgren@tele2.se>
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; version 2 of the License.
 *
 *   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.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public
 *   License along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

/*
v3  2005-09-29 & 2005-11-14
--

	Added swap, set_size_filled

v0.1.1  2005-07-21 - 2005-07-28
------

	Added insert & insert_this.
	Changed so that append & append_this is implemented through insert & insert_this.
	Changed so that operator[] preform boundary checking.

v0.1.0  2005-02-18 - 2005-02-19
------

	Basic vector-functionality works...

*/

#ifndef VECTOR_H_
#define VECTOR_H_

#include "vartypes.h"
#include "keyfile.h"

#define VECTOR_H_VERSION "v3"
#define VECTOR_H_DATE    "2005-02 - 2005-11"


template <typename Type>
class Vector
{
private:

	int size;
	Type **data;

public:
	Vector();
	Vector(const Vector<Type> &src) throw(error_obj);
	~Vector();

	void clear(void);

	void set_size(int new_size) throw(error_obj);
	void set_size_filled(int new_size) throw(error_obj);
	inline int get_size(void) const { return size; }

	inline void append(const Type &new_obj) throw(error_obj) { insert( new_obj, size ); }
	inline void append_this(Type *new_obj) throw(error_obj) { insert_this( new_obj, size ); }

	// illegal values of at_pos will be truncated to at_pos = size,
	// which will be the same as append'ing
	void insert(const Type &new_obj, int at_pos) throw(error_obj);
	void insert_this( Type *new_obj, int at_pos) throw(error_obj);

	void remove(int index);

	void swap(int i1, int i2);

	void operator=(const Vector<Type> &src) throw(error_obj);

	Type * operator[](int index) throw(error_obj);
	const Type * operator[](int index) const throw(error_obj);
};


template <typename Type>
Vector<Type>::Vector(void)
{
	data = 0;
	size = 0;
}

template <typename Type>
Vector<Type>::Vector(const Vector<Type> &src) throw(error_obj)
{
	data = 0;
	size = 0;
	*this = src;
}

template <typename Type>
Vector<Type>::~Vector()
{
	clear();
}

template <typename Type>
Type * Vector<Type>::operator[](int index) throw(error_obj)
{
	if( index < 0  ||  index >= size )
		THROW_ERROR( ErrorType_Memory, _("Index out-of-range in Vector::operator[]") );

	return data[index];
}

template <typename Type>
const Type * Vector<Type>::operator[](int index) const throw(error_obj)
{
	if( index < 0  ||  index >= size )
		THROW_ERROR( ErrorType_General, _("Index out-of-range in Vector::operator[]") );

	return data[index];
}

template <typename Type>
void Vector<Type>::operator=(const Vector &src) throw(error_obj)
{
	set_size( src.size );

	try
	{
		for( int i=0; i<size; i++ )
		{
			if( src.data[i] != 0 )
			{
				data[i] = new Type;
				*(data[i]) = *(src.data[i]);
			}
		}
	}
	catch(error_obj error)
	{
		clear();
		throw;
	}
	catch(...)
	{
		clear();
		THROW_ERROR( ErrorType_Memory, _("Couldn't get memory.") );
	}
}

template <typename Type>
void Vector<Type>::set_size_filled(int new_size) throw(error_obj)
{
	set_size( new_size );

	try
	{
		for( int i=0; i<size; i++ )
			data[i] = new Type;
	}
	catch(...) { THROW_ERROR( ErrorType_Memory, _("Couldn't get memory.") ); }
}

template <typename Type>
void Vector<Type>::set_size(int new_size) throw(error_obj)
{
	clear();

	if( new_size <= 0 )
		return;

	try
	{
		data = new Type * [new_size];
		size = new_size;
	}
	catch(...) { THROW_ERROR( ErrorType_Memory, _("Couldn't get memory.") ); }

	for( int i=0; i<size; i++ )
		data[i] = 0;
}

template <typename Type>
void Vector<Type>::clear(void)
{
	for( int i=0; i<size; i++ )
		delete data[i];

	delete [] data;

	data = 0;
	size = 0;
}

template <typename Type>
void Vector<Type>::remove(int index)
{
	if( index < 0  ||  index >= size )
		return;

	delete data[index];

	size--;

	for( int i=index; i<size; i++ )
		data[i] = data[i+1];
}

template <typename Type>
void Vector<Type>::swap(int i1, int i2)
{
	if( i1 < 0  ||  i1 >= size  ||  i2 < 0  ||  i2 >= size  ||  i1 == i2 )
		return;

	Type *tmp;

	tmp = data[i1];
	data[i1] = data[i2];
	data[i2] = tmp;
}

template <typename Type>
void Vector<Type>::insert(const Type &new_obj, int at_pos) throw(error_obj)
{
	Type *tmp;

	if( at_pos < 0  ||  at_pos > size )
		at_pos = size;

	try{  tmp = new Type;  }
	catch(...) {  THROW_ERROR( ErrorType_Memory, _("Couldn't get memory.") );  }

	try
	{
		*tmp = new_obj;
		insert_this( tmp, at_pos );
	}
	catch(...)
	{
		delete tmp;
		throw;
	}
}

template <typename Type>
void Vector<Type>::insert_this( Type *new_obj, int at_pos) throw(error_obj)
{
	if( at_pos < 0  ||  at_pos > size )
		at_pos = size;

	Type **old_data = data;
	int old_size = size, i;

	data = 0;
	size = 0;

	try
	{
		set_size( old_size+1 );
	}
	catch(...)
	{
		data = old_data;
		size = old_size;
		throw;
	}

	for( i=0; i<at_pos; i++ )
		data[i] = old_data[i];

	data[at_pos] = new_obj;

	for( i++; i<size; i++ )
		data[i] = old_data[i-1];

	delete [] old_data;
}

#endif // VECTOR_H_