/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#ifndef _SFXVARARR_HXX
#define _SFXVARARR_HXX

#include "sal/config.h"
#include "sfx2/dllapi.h"

#include <limits.h>
#include <string.h>
#include <tools/solar.h>
#include <tools/debug.hxx>
//#include "typecast.hxx"

#if defined (ALPHA) && defined (UNX)
#define DEL_ARRAY( X )
#else
#define DEL_ARRAY( X ) X
#endif

#define DECL_OBJARRAY( ARR, T, nI, nG ) \
class ARR\
{\
private:\
	T*	 pData;\
    sal_uInt16  nUsed;\
	sal_uInt8	nGrow;\
    sal_uInt8    nUnused;\
public:\
	ARR( sal_uInt8 nInitSize = nI, sal_uInt8 nGrowSize = nG );\
	ARR( const ARR& rOrig );\
	~ARR();\
\
	ARR& operator= ( const ARR& rOrig );\
\
	const T& GetObject( sal_uInt16 nPos ) const; \
	T& GetObject( sal_uInt16 nPos ); \
\
	void Insert( sal_uInt16 nPos, ARR& rIns, sal_uInt16 nStart = 0, sal_uInt16 nEnd = USHRT_MAX );\
	void Insert( sal_uInt16 nPos, const T& rElem );\
	void Insert( sal_uInt16 nPos, const T& rElems, sal_uInt16 nLen );\
	void Append( const T& rElem );\
\
	sal_Bool Remove( const T& rElem );\
	sal_uInt16 Remove( sal_uInt16 nPos, sal_uInt16 nLen );\
\
	sal_uInt16 Count() const { return nUsed; }\
	T* operator*();\
	const T& operator[]( sal_uInt16 nPos ) const;\
	T& operator[]( sal_uInt16 nPos );\
\
	sal_Bool Contains( const T& rItem ) const;\
	void Clear() { Remove( 0, Count() ); }\
};\
\
inline void ARR::Insert( sal_uInt16 nPos, ARR& rIns, sal_uInt16 nStart, sal_uInt16 nEnd )\
{\
	Insert( nPos, *(rIns.pData+(sizeof(T)*nStart)), nStart-nEnd+1 );\
}\
\
inline void ARR::Insert( sal_uInt16 nPos, const T& rElem )\
{\
	Insert( nPos, rElem, 1 );\
}\
\
inline T* ARR::operator*()\
{\
	return ( nUsed==0 ? 0 : pData );\
} \
inline const T& ARR::operator[]( sal_uInt16 nPos ) const\
{\
    DBG_ASSERT( nPos < nUsed, "" ); \
    return *(pData+nPos);\
} \
inline T& ARR::operator [] (sal_uInt16 nPos) \
{\
    DBG_ASSERT( nPos < nUsed, "" ); \
    return *(pData+nPos); \
} \
inline const T& ARR::GetObject( sal_uInt16 nPos ) const { return operator[](nPos); } \
inline T& ARR::GetObject( sal_uInt16 nPos ) { return operator[](nPos); } \

#ifndef _lint
// String too long

#define IMPL_OBJARRAY( ARR, T ) \
ARR::ARR( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ): \
	nUsed(0), \
	nGrow( nGrowSize ? nGrowSize : 1 ), \
	nUnused(nInitSize) \
{ \
	if ( nInitSize != 0 ) \
	{ \
		size_t nBytes = nInitSize * sizeof(T); \
		pData = (T*) new char[ nBytes ]; \
		memset( pData, 0, nBytes ); \
	} \
	else \
		pData = 0; \
} \
\
ARR::ARR( const ARR& rOrig ) \
{ \
	nUsed = rOrig.nUsed; \
	nGrow = rOrig.nGrow; \
	nUnused = rOrig.nUnused; \
\
	if ( rOrig.pData != 0 ) \
	{ \
		size_t nBytes = (nUsed + nUnused) * sizeof(T); \
		pData = (T*) new char [ nBytes ]; \
		memset( pData, 0, nBytes ); \
        for ( sal_uInt16 n = 0; n < nUsed; ++n ) \
            *(pData+n) = *(rOrig.pData+n); \
	} \
	else \
		pData = 0; \
} \
\
ARR::~ARR() \
{ \
	for ( sal_uInt16 n = 0; n < nUsed; ++n ) \
		( pData+n )->T::~T(); \
	delete[] (char*) pData;\
} \
\
ARR& ARR::operator= ( const ARR& rOrig )\
{ \
	for ( sal_uInt16 n = 0; n < nUsed; ++n ) \
		( pData+n )->T::~T(); \
    delete[] (char*) pData;\
\
	nUsed = rOrig.nUsed; \
	nGrow = rOrig.nGrow; \
	nUnused = rOrig.nUnused; \
\
	if ( rOrig.pData != 0 ) \
	{ \
		size_t nBytes = (nUsed + nUnused) * sizeof(T); \
		pData = (T*) new char[ nBytes ]; \
		memset( pData, 0, nBytes ); \
        for ( sal_uInt16 n = 0; n < nUsed; ++n ) \
            *(pData+n) = *(rOrig.pData+n); \
	} \
	else \
		pData = 0; \
	return *this; \
} \
\
void ARR::Append( const T& aElem ) \
{ \
	 \
	if ( nUnused == 0 ) \
	{ \
		sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow; \
		size_t nBytes = nNewSize * sizeof(T); \
		T* pNewData = (T*) new char[ nBytes ]; \
		memset( pNewData, 0, nBytes ); \
        if ( pData ) \
		{ \
			memcpy( pNewData, pData, nUsed * sizeof(T) ); \
			delete[] (char*) pData;\
		} \
		nUnused = (sal_uInt8)(nNewSize-nUsed); \
		pData = pNewData; \
	} \
\
	 \
	pData[nUsed] = aElem; \
	++nUsed; \
	--nUnused; \
} \
\
sal_uInt16 ARR::Remove( sal_uInt16 nPos, sal_uInt16 nLen ) \
{ \
	DBG_ASSERT( (nPos+nLen) < (nUsed+1), "" ); \
	DBG_ASSERT( nLen > 0, "" ); \
\
	nLen = Min( (sal_uInt16)(nUsed-nPos), (sal_uInt16)nLen ); \
\
	if ( nLen == 0 ) \
		return 0; \
\
	for ( sal_uInt16 n = nPos; n < (nPos+nLen); ++n ) \
		( pData+n )->T::~T(); \
\
	if ( (nUsed-nLen) == 0 ) \
	{ \
		delete[] (char*) pData;\
		pData = 0; \
		nUsed = 0; \
		nUnused = 0; \
		return nLen; \
	} \
\
	if ( (nUnused+nLen) >= nGrow ) \
	{ \
		sal_uInt16 nNewUsed = nUsed-nLen; \
		sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow; \
		DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize, \
					"shrink size computation failed" ); \
		size_t nBytes = nNewSize * sizeof(T); \
		T* pNewData = (T*) new char[ nBytes ]; \
		memset( pNewData, 0, nBytes ); \
		if ( nPos > 0 ) \
			memcpy( pNewData, pData, nPos * sizeof(T) ); \
		if ( nNewUsed != nPos ) \
			memcpy(pNewData+nPos, pData+nPos+nLen, (nNewUsed-nPos) * sizeof(T) ); \
		delete[] (char*) pData;\
		pData = pNewData; \
		nUsed = nNewUsed; \
		nUnused = (sal_uInt8)(nNewSize - nNewUsed); \
		return nLen; \
	} \
\
	 \
	if ( nUsed-nPos-nLen > 0 ) \
	{ \
		memmove(pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen) * sizeof(T));\
	} \
	nUsed = nUsed - nLen; \
	nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen); \
	return nLen; \
} \
\
sal_Bool ARR::Remove( const T& aElem ) \
{ \
	if ( nUsed == 0 ) \
		return sal_False; \
\
	const T *pIter = pData + nUsed - 1; \
	for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter ) \
		if ( *pIter == aElem ) \
		{ \
			Remove(nUsed-n-1, 1); \
			return sal_True; \
		} \
	return sal_False; \
} \
\
sal_Bool ARR::Contains( const T& rItem ) const \
{ \
	if ( !nUsed ) \
		return sal_False; \
	for ( sal_uInt16 n = 0; n < nUsed; ++n ) \
	{ \
		const T& r2ndItem = GetObject(n); \
		if ( r2ndItem == rItem ) \
			return sal_True; \
	} \
	return sal_False; \
} \
\
void ARR::Insert( sal_uInt16 nPos, const T& rElems, sal_uInt16 nLen ) \
{ \
	DBG_ASSERT( nPos <= nUsed, "" ); \
	 \
	if ( nUnused == 0 ) \
	{ \
		\
		/* auf die naechste Grow-Grenze aufgerundet vergroeszern */ \
		sal_uInt16 nNewSize; \
		for ( nNewSize = nUsed+nGrow; nNewSize < (nUsed + nLen); ++nNewSize ) \
			/* empty loop */; \
		size_t nBytes = nNewSize * sizeof(T); \
		T* pNewData = (T*) new char[ nBytes ]; \
		memset( pNewData, 0, nBytes ); \
		\
		if ( pData ) \
		{ \
			DBG_ASSERT( nUsed < nNewSize, "" ); \
			memcpy( pNewData, pData, nUsed * sizeof(T) ); \
			delete (char*) pData;\
		} \
		nUnused = (sal_uInt8)(nNewSize-nUsed); \
		pData = pNewData; \
	} \
\
	 \
	if ( nPos < nUsed ) \
	{ \
        memmove(pData+nPos+nLen-1, pData+nPos-1, sizeof(T) * (nUsed-nPos));	\
	} \
\
    memmove(pData+nPos, &rElems, sizeof(T) * nLen);	\
	nUsed = nUsed + nLen; \
	nUnused = sal::static_int_cast< sal_uInt8 >(nUnused - nLen); \
}

// _lint
#endif

class SFX2_DLLPUBLIC SfxPtrArr
{
private:
	void** pData;
	sal_uInt16 nUsed;
	sal_uInt8 nGrow;
	sal_uInt8 nUnused;
public:
	SfxPtrArr( sal_uInt8 nInitSize = 0, sal_uInt8 nGrowSize = 8 );
	SfxPtrArr( const SfxPtrArr& rOrig );
	~SfxPtrArr();
	SfxPtrArr& operator= ( const SfxPtrArr& rOrig );
	void* GetObject( sal_uInt16 nPos ) const { return operator[](nPos); }
	void*& GetObject( sal_uInt16 nPos ) { return operator[](nPos); }
	void Insert( sal_uInt16 nPos, void* rElem );
	void Append( void* rElem );
	sal_Bool Replace( void* pOldElem, void* pNewElem );
	sal_Bool Remove( void* rElem );
	sal_uInt16 Remove( sal_uInt16 nPos, sal_uInt16 nLen );
	sal_uInt16 Count() const { return nUsed; }
	inline void** operator*();
	inline void* operator[]( sal_uInt16 nPos ) const;
	inline void*& operator[]( sal_uInt16 nPos );
	sal_Bool Contains( const void* rItem ) const;
	void Clear() { Remove( 0, Count() ); }
};

inline void** SfxPtrArr::operator*()
{
	return ( nUsed==0 ? 0 : pData );
}

inline void* SfxPtrArr::operator[]( sal_uInt16 nPos ) const
{
	DBG_ASSERT( nPos < nUsed, "" );
	return *(pData+nPos);
}

inline void*& SfxPtrArr::operator [] (sal_uInt16 nPos)
{
	DBG_ASSERT( nPos < nUsed, "" );
	return *(pData+nPos);
}


#define DECL_PTRARRAY(ARR, T, nI, nG)\
class ARR: public SfxPtrArr\
{\
public:\
   ARR( sal_uInt8 nIni=nI, sal_uInt8 nGrowValue=nG ):\
	   SfxPtrArr(nIni,nGrowValue) \
   {}\
   ARR( const ARR& rOrig ):\
	   SfxPtrArr(rOrig) \
   {}\
   T GetObject( sal_uInt16 nPos ) const { return operator[](nPos); } \
   T& GetObject( sal_uInt16 nPos ) { return operator[](nPos); } \
   void Insert( sal_uInt16 nPos, T aElement ) {\
	   SfxPtrArr::Insert(nPos,(void *)aElement);\
   }\
   void Append( T aElement ) {\
	   SfxPtrArr::Append((void *)aElement);\
   }\
   sal_Bool Replace( T aOldElem, T aNewElem ) {\
       return SfxPtrArr::Replace((void *)aOldElem, (void*) aNewElem);\
   }\
   void Remove( T aElement ) {\
	   SfxPtrArr::Remove((void*)aElement);\
   }\
   void Remove( sal_uInt16 nPos, sal_uInt16 nLen = 1 ) {\
	   SfxPtrArr::Remove( nPos, nLen ); \
   }\
   T* operator *() {\
	   return (T*) SfxPtrArr::operator*();\
   }\
   T operator[]( sal_uInt16 nPos ) const { \
	   return (T) SfxPtrArr::operator[](nPos); } \
   T& operator[]( sal_uInt16 nPos ) { \
	   return (T&) SfxPtrArr::operator[](nPos); } \
   void Clear() { Remove( 0, Count() ); }\
};

class ByteArr
{
private:
	char* pData;
	sal_uInt16 nUsed;
	sal_uInt8 nGrow;
	sal_uInt8 nUnused;
public:
	ByteArr( sal_uInt8 nInitSize = 0, sal_uInt8 nGrowSize = 8 );
	ByteArr( const ByteArr& rOrig );
	~ByteArr();
	ByteArr& operator= ( const ByteArr& rOrig );
	char GetObject( sal_uInt16 nPos ) const { return operator[](nPos); }
	char& GetObject( sal_uInt16 nPos ) { return operator[](nPos); }
	void Insert( sal_uInt16 nPos, char rElem );
	void Append( char rElem );
	sal_Bool Remove( char rElem );
	sal_uInt16 Remove( sal_uInt16 nPos, sal_uInt16 nLen );
	sal_uInt16 Count() const { return nUsed; }
	char* operator*();
	char operator[]( sal_uInt16 nPos ) const;
	char& operator[]( sal_uInt16 nPos );
	sal_Bool Contains( const char rItem ) const;
	void Clear() { Remove( 0, Count() ); }
};

inline char* ByteArr::operator*()
{
	return ( nUsed==0 ? 0 : pData );
}

#define DECL_1BYTEARRAY(ARR, T, nI, nG)\
class ARR: public ByteArr\
{\
public:\
		ARR( sal_uInt8 nIni=nI, sal_uInt8 nGrow=nG ):\
			ByteArr(nIni,nGrow) \
		{}\
		ARR( const ARR& rOrig ):\
			ByteArr(rOrig) \
		{}\
		T GetObject( sal_uInt16 nPos ) const { return operator[](nPos); } \
		T& GetObject( sal_uInt16 nPos ) { return operator[](nPos); } \
		void Insert( sal_uInt16 nPos, T aElement ) {\
			ByteArr::Insert(nPos,(char)aElement);\
		}\
		void Append( T aElement ) {\
			ByteArr::Append((char)aElement);\
		}\
		void Remove( T aElement ) {\
			ByteArr::Remove((char)aElement);\
		}\
		void Remove( sal_uInt16 nPos, sal_uInt16 nLen = 1 ) {\
			ByteArr::Remove( nPos, nLen ); \
		}\
		T* operator *() {\
			return (T*) ByteArr::operator*();\
		}\
		T operator[]( sal_uInt16 nPos ) const { \
			return (T) ByteArr::operator[](nPos); } \
		T& operator[]( sal_uInt16 nPos ) { \
			return (T&) ByteArr::operator[](nPos); } \
		void Clear() { Remove( 0, Count() ); }\
};

class WordArr
{
private:
	short* pData;
	sal_uInt16 nUsed;
	sal_uInt8 nGrow;
	sal_uInt8 nUnused;
public:
	WordArr( sal_uInt8 nInitSize = 0, sal_uInt8 nGrowSize = 8 );
	WordArr( const WordArr& rOrig );
	~WordArr();
	WordArr& operator= ( const WordArr& rOrig );
	short GetObject( sal_uInt16 nPos ) const { return operator[](nPos); }
	short& GetObject( sal_uInt16 nPos ) { return operator[](nPos); }
	void Insert( sal_uInt16 nPos, short rElem );
	void Append( short rElem );
	sal_Bool Remove( short rElem );
	sal_uInt16 Remove( sal_uInt16 nPos, sal_uInt16 nLen );
	sal_uInt16 Count() const { return nUsed; }
	short* operator*();
	short operator[]( sal_uInt16 nPos ) const;
	short& operator[]( sal_uInt16 nPos );
	sal_Bool Contains( const short rItem ) const;
	void Clear() { Remove( 0, Count() ); }
};

inline short* WordArr::operator*()
{
	return ( nUsed==0 ? 0 : pData );
}

#define DECL_2BYTEARRAY(ARR, T, nI, nG)\
class ARR: public WordArr\
{\
public:\
		ARR( sal_uInt8 nIni=nI, sal_uInt8 nGrowValue=nG ):\
			WordArr(nIni,nGrowValue) \
		{}\
		ARR( const ARR& rOrig ):\
			WordArr(rOrig) \
		{}\
		T GetObject( sal_uInt16 nPos ) const { return operator[](nPos); } \
		T& GetObject( sal_uInt16 nPos ) { return operator[](nPos); } \
		void Insert( sal_uInt16 nPos, T aElement ) {\
			WordArr::Insert(nPos,(short)aElement);\
		}\
		void Append( T aElement ) {\
			WordArr::Append((short)aElement);\
		}\
		void Remove( T aElement ) {\
			WordArr::Remove((short)aElement);\
		}\
		void Remove( sal_uInt16 nPos, sal_uInt16 nLen = 1 ) {\
			WordArr::Remove( nPos, nLen ); \
		}\
		T* operator *() {\
			return (T*) WordArr::operator*();\
		}\
		T operator[]( sal_uInt16 nPos ) const { \
			return (T) WordArr::operator[](nPos); } \
		T& operator[]( sal_uInt16 nPos ) { \
			return (T&) WordArr::operator[](nPos); } \
		void Clear() { Remove( 0, Count() ); }\
};

#endif