#include "vtkBESSArray.h"
#include <wx/string.h>
#define CString wxString
//***** C B E S S A r r a y

template <class type>
vtkBESSArray<type>::vtkBESSArray( const UINT c_uSize, const UINT c_uReserve /* = 0 */ )
{
	m_pData = NULL;
	if( (m_uMemSize = c_uSize + c_uReserve) && (m_pData = new type[m_uMemSize]) == NULL )
		throw CString( "Insufficient memory for array handling." );
	m_uSize = c_uSize;
	#ifdef _DEBUG
		m_yNLocks = 0;
	#endif
}

template <class type>
vtkBESSArray<type>::vtkBESSArray( const vtkBaseArray<type>& c_a, const UINT c_uReserve /* = 0 */ )
{
	m_pData = NULL;
	if( (m_uMemSize = c_a.Size() + c_uReserve) && (m_pData = new type[m_uMemSize]) == NULL )
		throw CString( "Insufficient memory for array handling." );
	m_uSize = c_a.Size();
	for( UINT uEl = 0;  uEl < c_a.Size();  uEl++ )
		m_pData[uEl] = c_a[uEl];
	#ifdef _DEBUG
		m_yNLocks = 0;
	#endif
}
template <class type>
void vtkBESSArray<type>::Clear() {
	assert( !m_yNLocks );
	if( m_uMemSize )
	{ 
		delete[] m_pData;
		m_pData = NULL;
		m_uSize = m_uMemSize = 0;
	};
};

//***** A p p e n d

template <class type>
void vtkBESSArray<type>::Append( const vtkBaseArray<type>& c_a )
{
	assert( !m_yNLocks );
	UINT uOldSize = m_uSize, uEl;
	IncreaseSizeBy( c_a.Size() );
	for( uEl = 0;  uEl < c_a.Size();  uEl++ )
		m_pData[uOldSize + uEl] = c_a[uEl];
}



//***** E x t r a c t

// private
template <class type>
void vtkBESSArray<type>::Extract( const vtkBaseArray<type>& c_a, const UINT c_uFirst, const UINT c_uNEl /* = 3 */ )
{
	// assert array defined
	assert( c_a.Defined() );

	// assert valid range of rows and columns of the input matrix addressed
	assert( c_uFirst + c_uNEl <= c_a.Size() );

	// set array size
	SetSize( c_uNEl );

	// install new data
	for( UINT uEl = 0;  uEl < m_uSize;  uEl++ )
		m_pData[uEl] = c_a[c_uFirst + uEl];
}


//***** I n c r e a s e S i z e B y

// private
template <class type>
void vtkBESSArray<type>::IncreaseSizeBy( const UINT c_uInc )
{
	// array size should be increased
	assert( c_uInc > 0 );

	// assert no subarray defined containing data of the array
	assert( !m_yNLocks );

	// assure sufficient memory
	UINT uEl;
	if( m_uSize + c_uInc > m_uMemSize )
	{
		// reserve new memory
		type* pOldData = m_pData;
		if( (m_pData = new type[m_uMemSize = m_uSize + c_uInc + ARRAY_INC_MEM_STEP]) == NULL )
		{
			if( pOldData != NULL )
			{
				delete[] pOldData;
				m_uSize = m_uMemSize = 0;
			}
			throw CString( "Insufficient memory for array." );
		}

		// copy old part of array
		for( uEl = 0;  uEl < m_uSize;  uEl++ )
			m_pData[uEl] = pOldData[uEl];

		// install new array and delete old one
		if( pOldData != NULL )
			delete[] pOldData;
	}

	// initialize new part of array 
	for( uEl = 0;  uEl < c_uInc;  uEl++ )
		m_pData[m_uSize + uEl] = 0;

	// update dimension
	m_uSize += c_uInc;

}  // IncreaseSizeBy( const UINT c_uInc )


//***** R e a d

template <class type>
void vtkBESSArray<type>::Read( const char *c_pcFilePath, const UINT c_uReserve /* = 0 */ )
{
	// assert no subarray defined containing data of the array
	assert( !m_yNLocks );

	// open file
	FILE	 *pDataFile;
	if( (pDataFile = fopen( c_pcFilePath,"rb" )) == NULL )
	{
 		Clear();
		CString sError;
		sError.Format( "Cannot open the data file\n'%s':\n%s",c_pcFilePath,_strerror( NULL ) );
		throw sError;
	}

	// read array size
	UINT  uSize;
	if( fread( &uSize,sizeof( UINT ),1,pDataFile ) != 1 )
	{
		CString sError;
		sError.Format( "Cannot read the data file\n'%s':\n%s",c_pcFilePath,_strerror( NULL ) );
		Clear();
		fclose( pDataFile );
		throw sError;
	}
	SetSize( uSize,c_uReserve );

	// read array elements
	if( fread( m_pData,sizeof( type ),uSize,pDataFile ) != uSize )
	{
		CString sError;
		sError.Format( "Cannot read the data file\n'%s':\n%s",c_pcFilePath,_strerror( NULL ) );
		fclose( pDataFile );
		Clear();
		throw sError;
	}
	fclose( pDataFile );

}  // Read( const char *c_pcFilePath, const UINT c_uReserve /* = 0 */ )


//***** R e m o v e

template <class type>
void vtkBESSArray<type>::Remove( const UINT c_uFirst, const UINT c_uN )
{
	// assert no subarray defined containing data of the array
	assert( !m_yNLocks );

	// assert valid range of array to be removed
	if( c_uFirst + c_uN > m_uSize )
		throw CString( "Removing invalid range of array." );

	// shift maintained array elements to the left to overwrite the removed elements
	UINT uNewIndex, uOldIndex;
	for( uNewIndex = c_uFirst, uOldIndex = c_uFirst + c_uN;
		 uOldIndex < m_uSize;  uNewIndex++, uOldIndex++		)
		m_pData[uNewIndex] = m_pData[uOldIndex];

	// update array size
	m_uSize -= c_uN;

}  // Remove( const UINT c_uFirst, const UINT c_uN )


//***** R e s e r v e

template <class type>
void vtkBESSArray<type>::Reserve( const UINT c_uMem )
{
	// assert no subarray defined containing data of the array
	assert( !m_yNLocks );

	m_uSize = 0;
	if( c_uMem > m_uMemSize )
	{
		if( m_uMemSize )
			delete[] m_pData;
		if( (m_pData = new type[m_uMemSize = c_uMem]) == NULL )
		{
			m_uSize = m_uMemSize = 0;
			throw CString( "Insufficient memory for array." );
		}
	}
}


//***** W r i t e

template <class type>
void vtkBESSArray<type>::Write( const char* c_pcFilePath ) const
{
	FILE *pDataFile;

	// open file
	if( !(pDataFile = fopen( c_pcFilePath,"wb" )) )
	{
		CString sError;
		sError.Format( "Cannot open the data file\n'%s':\n%s",c_pcFilePath,_strerror( NULL ) );
		throw sError;
	}

	// write array size
	if( fwrite( &m_uSize,sizeof( UINT ),1,pDataFile ) != 1 )
	{
		CString sError;
		sError.Format( "Cannot write to the data file\n'%s':\n%s",c_pcFilePath,_strerror( NULL ) );
		fclose( pDataFile );
		_unlink( c_pcFilePath );
		throw sError;
	}

	// write array elements
	if( fwrite( m_pData,sizeof( type ),m_uSize,pDataFile ) != m_uSize )
	{
		CString sError;
		sError.Format( "Cannot write to the data file\n'%s':\n%s",c_pcFilePath,_strerror( NULL ) );
		fclose( pDataFile );
		_unlink( c_pcFilePath );
		throw sError;
	}
	fclose( pDataFile );

}