#include "Array.h"

using namespace Framework;

// Inhalt der IntArray Klasse aus Array.h
// Konstruktor 
IntArray::IntArray()
{
	This = 0;
	next = 0;
}

// Destruktor 
IntArray::~IntArray()
{
	if( next )
		delete next;
}

// nicht constant 
void IntArray::addInt( int i, int index, int null ) // fügt i bei endex ein
{
	if( index == null )
	{
		IntArray *tmp = next;
		next = new IntArray();
		next->setNext( tmp );
		next->setInt( This, 0, 0 );
		This = i;
		return;
	}
	if( !next )
		next = new IntArray();
	next->addInt( i, index, null + 1 );
}

void IntArray::addInt( int i ) // fügt i hinzu
{
	if( !next )
	{
		next = new IntArray();
		next->setInt( i, 0, 0 );
		return;
	}
	next->addInt( i );
}

void IntArray::setInt( int i, int index, int null ) // setzt das index - te int zu i
{
	if( index == null )
	{
		This = i;
		return;
	}
	if( !next )
		next = new IntArray();
	next->setInt( i, index, null + 1 );
}

void IntArray::löscheInt( int index, int null ) // löscht das index - te int
{
	if( index == null )
	{
		This = 0;
		if( next )
		{
			This = next->zThis();
			IntArray *tmp = next->zNext();
			next->setNext( 0 );
			delete next;
			next = tmp;
		}
		return;
	}
	if( !next )
		next = new IntArray();
	next->löscheInt( index, null + 1 );
}

void IntArray::tauschInt( int vindex, int nindex ) // löscht das index - te int
{
	int tmp = getInt( nindex, 0 );
	setInt( getInt( vindex, 0 ), nindex, 0 );
	setInt( tmp, vindex, 0 );
}

void IntArray::setNext( IntArray *n ) // setzt den next Zeiger auf n
{
	next = n;
}

int IntArray::getInt( int index, int null ) // gibt das index - te int zurück
{
	if( index == null )
		return This;
	if( !next )
		next = new IntArray();
	return next->getInt( index, null + 1 );
}

void IntArray::deleteAll() // gibt den Speicher frei
{
	This = 0;
	if( next )
		next->deleteAll();
	delete next;
	next = 0;
}

IntArray *IntArray::release() // gibt den Speicher frei
{
	This = 0;
	if( next )
		next = next->release();
	delete this;
	return 0;
}

// constant 
int IntArray::zThis() const // gibt This zurück
{
	return This;
}

IntArray *IntArray::zNext() const // gibt den next Zeiger zurück
{
	return next;
}

// Inhalt der Int64Array Klasse aus Array.h
// Konstruktor 
Int64Array::Int64Array()
{
	This = 0;
	next = 0;
}

// Destruktor 
Int64Array::~Int64Array()
{
	if( next )
		delete next;
}

// nicht constant 
void Int64Array::addInt( __int64 i, int index, int null ) // fügt i bei endex ein
{
	if( index == null )
	{
		Int64Array *tmp = next;
		next = new Int64Array();
		next->setNext( tmp );
		next->setInt( This, 0, 0 );
		This = i;
		return;
	}
	if( !next )
		next = new Int64Array();
	next->addInt( i, index, null + 1 );
}

void Int64Array::setInt( __int64 i, int index, int null ) // setzt das index - te int zu i
{
	if( index == null )
	{
		This = i;
		return;
	}
	if( !next )
		next = new Int64Array();
	next->setInt( i, index, null + 1 );
}

void Int64Array::löscheInt( int index, int null ) // löscht das index - te int
{
	if( index == null )
	{
		This = 0;
		if( next )
		{
			This = next->zThis();
			Int64Array *tmp = next->zNext();
			next->setNext( 0 );
			delete next;
			next = tmp;
		}
		return;
	}
	if( !next )
		next = new Int64Array();
	next->löscheInt( index, null + 1 );
}

void Int64Array::tauschInt( int vindex, int nindex ) // löscht das index - te int
{
	__int64 tmp = getInt( nindex, 0 );
	setInt( getInt( vindex, 0 ), nindex, 0 );
	setInt( tmp, vindex, 0 );
}

void Int64Array::setNext( Int64Array *n ) // setzt den next Zeiger auf n
{
	next = n;
}

__int64 Int64Array::getInt( int index, int null ) // gibt das index - te int zurück
{
	if( index == null )
		return This;
	if( !next )
		next = new Int64Array();
	return next->getInt( index, null + 1 );
}

void Int64Array::deleteAll() // gibt den Speicher frei
{
	This = 0;
	if( next )
		next->deleteAll();
	delete next;
	next = 0;
}

Int64Array *Int64Array::release() // gibt den Speicher frei
{
	if( This )
		This = 0;
	if( next )
		next = next->release();
	delete this;
	return 0;
}

// constant 
__int64 Int64Array::zThis() const // gibt This zurück
{
	return This;
}

Int64Array *Int64Array::zNext() const // gibt den next Zeiger zurück
{
	return next;
}

// Inhalt der DoubleArray Klasse aus Array.h
// Konstruktor 
DoubleArray::DoubleArray()
{
	This = 0;
	next = 0;
}

// Destruktor 
DoubleArray::~DoubleArray()
{
	if( next )
		delete next;
}

// nicht constant 
void DoubleArray::addDouble( double i, int index, int null ) // fügt i bei endex ein
{
	if( index == null )
	{
		DoubleArray *tmp = next;
		next = new DoubleArray();
		next->setNext( tmp );
		next->setDouble( This, 0, 0 );
		This = i;
		return;
	}
	if( !next )
		next = new DoubleArray();
	next->addDouble( i, index, null + 1 );
}

void DoubleArray::setDouble( double i, int index, int null ) // setzt das index - te int zu i
{
	if( index == null )
	{
		This = i;
		return;
	}
	if( !next )
		next = new DoubleArray();
	next->setDouble( i, index, null + 1 );
}

void DoubleArray::löscheDouble( int index, int null ) // löscht das index - te int
{
	if( index == null )
	{
		This = 0;
		if( next )
		{
			This = next->zThis();
			DoubleArray *tmp = next->zNext();
			next->setNext( 0 );
			delete next;
			next = tmp;
		}
		return;
	}
	if( !next )
		next = new DoubleArray();
	next->löscheDouble( index, null + 1 );
}

void DoubleArray::tauschDouble( int vindex, int nindex ) // löscht das index - te int
{
	double tmp = getDouble( nindex, 0 );
	setDouble( getDouble( vindex, 0 ), nindex, 0 );
	setDouble( tmp, vindex, 0 );
}

void DoubleArray::setNext( DoubleArray *n ) // setzt den next Zeiger auf n
{
	next = n;
}

double DoubleArray::getDouble( int index, int null ) // gibt das index - te int zurück
{
	if( index == null )
		return This;
	if( !next )
		next = new DoubleArray();
	return next->getDouble( index, null + 1 );
}

void DoubleArray::deleteAll() // gibt den Speicher frei
{
	This = 0;
	if( next )
		next->deleteAll();
	delete next;
	next = 0;
}

DoubleArray *DoubleArray::release() // gibt den Speicher frei
{
	if( This )
		This = 0;
	if( next )
		next = next->release();
	delete this;
	return 0;
}

// constant 
double DoubleArray::zThis() const // gibt This zurück
{
	return This;
}

DoubleArray *DoubleArray::zNext() const // gibt den next Zeiger zurück
{
	return next;
}