summaryrefslogtreecommitdiff
path: root/sfx2/source/bastyp/minarray.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'sfx2/source/bastyp/minarray.cxx')
-rw-r--r--sfx2/source/bastyp/minarray.cxx156
1 files changed, 78 insertions, 78 deletions
diff --git a/sfx2/source/bastyp/minarray.cxx b/sfx2/source/bastyp/minarray.cxx
index 978239239cea..9559de4069b0 100644
--- a/sfx2/source/bastyp/minarray.cxx
+++ b/sfx2/source/bastyp/minarray.cxx
@@ -35,13 +35,13 @@
// -----------------------------------------------------------------------
-SfxPtrArr::SfxPtrArr( BYTE nInitSize, BYTE nGrowSize ):
+SfxPtrArr::SfxPtrArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ):
nUsed( 0 ),
nGrow( nGrowSize ? nGrowSize : 1 ),
nUnused( nInitSize )
{
DBG_MEMTEST();
- USHORT nMSCBug = nInitSize;
+ sal_uInt16 nMSCBug = nInitSize;
if ( nMSCBug > 0 )
pData = new void*[nMSCBug];
@@ -106,7 +106,7 @@ void SfxPtrArr::Append( void* aElem )
// musz das Array umkopiert werden?
if ( nUnused == 0 )
{
- USHORT nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
+ sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
void** pNewData = new void*[nNewSize];
if ( pData )
{
@@ -114,7 +114,7 @@ void SfxPtrArr::Append( void* aElem )
memmove( pNewData, pData, sizeof(void*)*nUsed );
delete [] pData;
}
- nUnused = sal::static_int_cast< BYTE >(nNewSize-nUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
pData = pNewData;
}
@@ -126,11 +126,11 @@ void SfxPtrArr::Append( void* aElem )
// -----------------------------------------------------------------------
-USHORT SfxPtrArr::Remove( USHORT nPos, USHORT nLen )
+sal_uInt16 SfxPtrArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen )
{
DBG_MEMTEST();
// nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird
- nLen = Min( (USHORT)(nUsed-nPos), nLen );
+ nLen = Min( (sal_uInt16)(nUsed-nPos), nLen );
// einfache Aufgaben erfordern einfache Loesungen!
if ( nLen == 0 )
@@ -150,8 +150,8 @@ USHORT SfxPtrArr::Remove( USHORT nPos, USHORT nLen )
if ( (nUnused+nLen) >= nGrow )
{
// auf die naechste Grow-Grenze aufgerundet verkleinern
- USHORT nNewUsed = nUsed-nLen;
- USHORT nNewSize = ((nNewUsed+nGrow-1)/nGrow) * 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" );
void** pNewData = new void*[nNewSize];
@@ -166,7 +166,7 @@ USHORT SfxPtrArr::Remove( USHORT nPos, USHORT nLen )
delete [] pData;
pData = pNewData;
nUsed = nNewUsed;
- nUnused = sal::static_int_cast< BYTE >(nNewSize - nNewUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed);
return nLen;
}
@@ -174,71 +174,71 @@ USHORT SfxPtrArr::Remove( USHORT nPos, USHORT nLen )
if ( nUsed-nPos-nLen > 0 )
memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(void*) );
nUsed = nUsed - nLen;
- nUnused = sal::static_int_cast< BYTE >(nUnused + nLen);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen);
return nLen;
}
// -----------------------------------------------------------------------
-BOOL SfxPtrArr::Remove( void* aElem )
+sal_Bool SfxPtrArr::Remove( void* aElem )
{
DBG_MEMTEST();
// einfache Aufgaben ...
if ( nUsed == 0 )
- return FALSE;
+ return sal_False;
// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
void* *pIter = pData + nUsed - 1;
- for ( USHORT n = 0; n < nUsed; ++n, --pIter )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
if ( *pIter == aElem )
{
Remove(nUsed-n-1, 1);
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-BOOL SfxPtrArr::Replace( void* aOldElem, void* aNewElem )
+sal_Bool SfxPtrArr::Replace( void* aOldElem, void* aNewElem )
{
DBG_MEMTEST();
// einfache Aufgaben ...
if ( nUsed == 0 )
- return FALSE;
+ return sal_False;
// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
void* *pIter = pData + nUsed - 1;
- for ( USHORT n = 0; n < nUsed; ++n, --pIter )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
if ( *pIter == aOldElem )
{
pData[nUsed-n-1] = aNewElem;
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-BOOL SfxPtrArr::Contains( const void* rItem ) const
+sal_Bool SfxPtrArr::Contains( const void* rItem ) const
{
DBG_MEMTEST();
if ( !nUsed )
- return FALSE;
+ return sal_False;
- for ( USHORT n = 0; n < nUsed; ++n )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n )
{
void* p = GetObject(n);
if ( p == rItem )
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-void SfxPtrArr::Insert( USHORT nPos, void* rElem )
+void SfxPtrArr::Insert( sal_uInt16 nPos, void* rElem )
{
DBG_MEMTEST();
DBG_ASSERT( sal::static_int_cast< unsigned >(nUsed+1) < ( USHRT_MAX / sizeof(void*) ), "array too large" );
@@ -246,7 +246,7 @@ void SfxPtrArr::Insert( USHORT nPos, void* rElem )
if ( nUnused == 0 )
{
// auf die naechste Grow-Grenze aufgerundet vergroeszern
- USHORT nNewSize = nUsed+nGrow;
+ sal_uInt16 nNewSize = nUsed+nGrow;
void** pNewData = new void*[nNewSize];
if ( pData )
@@ -255,7 +255,7 @@ void SfxPtrArr::Insert( USHORT nPos, void* rElem )
memmove( pNewData, pData, sizeof(void*)*nUsed );
delete [] pData;
}
- nUnused = sal::static_int_cast< BYTE >(nNewSize-nUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
pData = pNewData;
}
@@ -271,13 +271,13 @@ void SfxPtrArr::Insert( USHORT nPos, void* rElem )
// class ByteArr ---------------------------------------------------------
-ByteArr::ByteArr( BYTE nInitSize, BYTE nGrowSize ):
+ByteArr::ByteArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ):
nUsed( 0 ),
nGrow( nGrowSize ? nGrowSize : 1 ),
nUnused( nInitSize )
{
DBG_MEMTEST();
- USHORT nMSCBug = nInitSize;
+ sal_uInt16 nMSCBug = nInitSize;
if ( nInitSize > 0 )
pData = new char[nMSCBug];
@@ -341,7 +341,7 @@ void ByteArr::Append( char aElem )
// musz das Array umkopiert werden?
if ( nUnused == 0 )
{
- USHORT nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
+ sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
char* pNewData = new char[nNewSize];
if ( pData )
{
@@ -349,7 +349,7 @@ void ByteArr::Append( char aElem )
memmove( pNewData, pData, sizeof(char)*nUsed );
delete [] pData;
}
- nUnused = sal::static_int_cast< BYTE >(nNewSize-nUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
pData = pNewData;
}
@@ -361,11 +361,11 @@ void ByteArr::Append( char aElem )
// -----------------------------------------------------------------------
-USHORT ByteArr::Remove( USHORT nPos, USHORT nLen )
+sal_uInt16 ByteArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen )
{
DBG_MEMTEST();
// nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird
- nLen = Min( (USHORT)(nUsed-nPos), nLen );
+ nLen = Min( (sal_uInt16)(nUsed-nPos), nLen );
// einfache Aufgaben erfordern einfache Loesungen!
if ( nLen == 0 )
@@ -385,8 +385,8 @@ USHORT ByteArr::Remove( USHORT nPos, USHORT nLen )
if ( (nUnused+nLen) >= nGrow )
{
// auf die naechste Grow-Grenze aufgerundet verkleinern
- USHORT nNewUsed = nUsed-nLen;
- USHORT nNewSize = ((nNewUsed+nGrow-1)/nGrow) * 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" );
char* pNewData = new char[nNewSize];
@@ -401,7 +401,7 @@ USHORT ByteArr::Remove( USHORT nPos, USHORT nLen )
delete [] pData;
pData = pNewData;
nUsed = nNewUsed;
- nUnused = sal::static_int_cast< BYTE >(nNewSize - nNewUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed);
return nLen;
}
@@ -409,58 +409,58 @@ USHORT ByteArr::Remove( USHORT nPos, USHORT nLen )
if ( nUsed-nPos-nLen > 0 )
memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(char) );
nUsed = nUsed - nLen;
- nUnused = sal::static_int_cast< BYTE >(nUnused + nLen);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen);
return nLen;
}
// -----------------------------------------------------------------------
-BOOL ByteArr::Remove( char aElem )
+sal_Bool ByteArr::Remove( char aElem )
{
DBG_MEMTEST();
// einfache Aufgaben ...
if ( nUsed == 0 )
- return FALSE;
+ return sal_False;
// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
char *pIter = pData + nUsed - 1;
- for ( USHORT n = 0; n < nUsed; ++n, --pIter )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
if ( *pIter == aElem )
{
Remove(nUsed-n-1, 1);
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-BOOL ByteArr::Contains( const char rItem ) const
+sal_Bool ByteArr::Contains( const char rItem ) const
{
DBG_MEMTEST();
if ( !nUsed )
- return FALSE;
+ return sal_False;
- for ( USHORT n = 0; n < nUsed; ++n )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n )
{
char p = GetObject(n);
if ( p == rItem )
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-void ByteArr::Insert( USHORT nPos, char rElem )
+void ByteArr::Insert( sal_uInt16 nPos, char rElem )
{
DBG_MEMTEST();
// musz das Array umkopiert werden?
if ( nUnused == 0 )
{
// auf die naechste Grow-Grenze aufgerundet vergroeszern
- USHORT nNewSize = nUsed+nGrow;
+ sal_uInt16 nNewSize = nUsed+nGrow;
char* pNewData = new char[nNewSize];
if ( pData )
@@ -469,7 +469,7 @@ void ByteArr::Insert( USHORT nPos, char rElem )
memmove( pNewData, pData, sizeof(char)*nUsed );
delete [] pData;
}
- nUnused = sal::static_int_cast< BYTE >(nNewSize-nUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
pData = pNewData;
}
@@ -485,7 +485,7 @@ void ByteArr::Insert( USHORT nPos, char rElem )
// -----------------------------------------------------------------------
-char ByteArr::operator[]( USHORT nPos ) const
+char ByteArr::operator[]( sal_uInt16 nPos ) const
{
DBG_MEMTEST();
DBG_ASSERT( nPos < nUsed, "" );
@@ -494,7 +494,7 @@ char ByteArr::operator[]( USHORT nPos ) const
// -----------------------------------------------------------------------
-char& ByteArr::operator [] (USHORT nPos)
+char& ByteArr::operator [] (sal_uInt16 nPos)
{
DBG_MEMTEST();
DBG_ASSERT( nPos < nUsed, "" );
@@ -503,13 +503,13 @@ char& ByteArr::operator [] (USHORT nPos)
// class WordArr ---------------------------------------------------------
-WordArr::WordArr( BYTE nInitSize, BYTE nGrowSize ):
+WordArr::WordArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ):
nUsed( 0 ),
nGrow( nGrowSize ? nGrowSize : 1 ),
nUnused( nInitSize )
{
DBG_MEMTEST();
- USHORT nMSCBug = nInitSize;
+ sal_uInt16 nMSCBug = nInitSize;
if ( nInitSize > 0 )
pData = new short[nMSCBug];
@@ -573,7 +573,7 @@ void WordArr::Append( short aElem )
// musz das Array umkopiert werden?
if ( nUnused == 0 )
{
- USHORT nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
+ sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
short* pNewData = new short[nNewSize];
if ( pData )
{
@@ -581,7 +581,7 @@ void WordArr::Append( short aElem )
memmove( pNewData, pData, sizeof(short)*nUsed );
delete [] pData;
}
- nUnused = sal::static_int_cast< BYTE >(nNewSize-nUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
pData = pNewData;
}
@@ -593,11 +593,11 @@ void WordArr::Append( short aElem )
// -----------------------------------------------------------------------
-USHORT WordArr::Remove( USHORT nPos, USHORT nLen )
+sal_uInt16 WordArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen )
{
DBG_MEMTEST();
// nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird
- nLen = Min( (USHORT)(nUsed-nPos), nLen );
+ nLen = Min( (sal_uInt16)(nUsed-nPos), nLen );
// einfache Aufgaben erfordern einfache Loesungen!
if ( nLen == 0 )
@@ -617,8 +617,8 @@ USHORT WordArr::Remove( USHORT nPos, USHORT nLen )
if ( (nUnused+nLen) >= nGrow )
{
// auf die naechste Grow-Grenze aufgerundet verkleinern
- USHORT nNewUsed = nUsed-nLen;
- USHORT nNewSize = ((nNewUsed+nGrow-1)/nGrow) * 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" );
short* pNewData = new short[nNewSize];
@@ -633,7 +633,7 @@ USHORT WordArr::Remove( USHORT nPos, USHORT nLen )
delete [] pData;
pData = pNewData;
nUsed = nNewUsed;
- nUnused = sal::static_int_cast< BYTE >(nNewSize - nNewUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed);
return nLen;
}
@@ -641,58 +641,58 @@ USHORT WordArr::Remove( USHORT nPos, USHORT nLen )
if ( nUsed-nPos-nLen > 0 )
memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(short) );
nUsed = nUsed - nLen;
- nUnused = sal::static_int_cast< BYTE >(nUnused + nLen);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen);
return nLen;
}
// -----------------------------------------------------------------------
-BOOL WordArr::Remove( short aElem )
+sal_Bool WordArr::Remove( short aElem )
{
DBG_MEMTEST();
// einfache Aufgaben ...
if ( nUsed == 0 )
- return FALSE;
+ return sal_False;
// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
short *pIter = pData + nUsed - 1;
- for ( USHORT n = 0; n < nUsed; ++n, --pIter )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
if ( *pIter == aElem )
{
Remove(nUsed-n-1, 1);
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-BOOL WordArr::Contains( const short rItem ) const
+sal_Bool WordArr::Contains( const short rItem ) const
{
DBG_MEMTEST();
if ( !nUsed )
- return FALSE;
+ return sal_False;
- for ( USHORT n = 0; n < nUsed; ++n )
+ for ( sal_uInt16 n = 0; n < nUsed; ++n )
{
short p = GetObject(n);
if ( p == rItem )
- return TRUE;
+ return sal_True;
}
- return FALSE;
+ return sal_False;
}
// -----------------------------------------------------------------------
-void WordArr::Insert( USHORT nPos, short rElem )
+void WordArr::Insert( sal_uInt16 nPos, short rElem )
{
DBG_MEMTEST();
// musz das Array umkopiert werden?
if ( nUnused == 0 )
{
// auf die naechste Grow-Grenze aufgerundet vergroeszern
- USHORT nNewSize = nUsed+nGrow;
+ sal_uInt16 nNewSize = nUsed+nGrow;
short* pNewData = new short[nNewSize];
if ( pData )
@@ -701,7 +701,7 @@ void WordArr::Insert( USHORT nPos, short rElem )
memmove( pNewData, pData, sizeof(short)*nUsed );
delete [] pData;
}
- nUnused = sal::static_int_cast< BYTE >(nNewSize-nUsed);
+ nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
pData = pNewData;
}
@@ -717,7 +717,7 @@ void WordArr::Insert( USHORT nPos, short rElem )
// -----------------------------------------------------------------------
-short WordArr::operator[]( USHORT nPos ) const
+short WordArr::operator[]( sal_uInt16 nPos ) const
{
DBG_MEMTEST();
DBG_ASSERT( nPos < nUsed, "" );
@@ -726,7 +726,7 @@ short WordArr::operator[]( USHORT nPos ) const
// -----------------------------------------------------------------------
-short& WordArr::operator [] (USHORT nPos)
+short& WordArr::operator [] (sal_uInt16 nPos)
{
DBG_MEMTEST();
DBG_ASSERT( nPos < nUsed, "" );
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-20 05:14:31 +0000