binfilter/inc/bf_sfx2/minarray.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: minarray.hxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _SFXVARARR_HXX
  31 #define _SFXVARARR_HXX
  32
  33 #include <limits.h>
  34 #include <string.h>
  35
  36 #ifndef _SOLAR_H
  37 #include <tools/solar.h>
  38 #endif
  39
  40 #ifndef _DEBUG_HXX //autogen
  41 #include <tools/debug.hxx>
  42 #endif
  43 namespace binfilter {
  44 //#include "typecast.hxx"
  45
  46 #if defined (ALPHA) && defined (UNX)
  47 #define DEL_ARRAY( X )
  48 #else
  49 #define DEL_ARRAY( X ) X
  50 #endif
  51
  52 #define DECL_OBJARRAY( ARR, T, nI, nG ) \
  53 class ARR\
  54 {\
  55 private:\
  56         T*       pData;\
  57     USHORT  nUsed;\
  58         BYTE    nGrow;\
  59     BYTE    nUnused;\
  60 public:\
  61         ARR( BYTE nInitSize = nI, BYTE nGrowSize = nG );\
  62         ARR( const ARR& rOrig );\
  63         ~ARR();\
  64 \
  65         ARR& operator= ( const ARR& rOrig );\
  66 \
  67         const T& GetObject( USHORT nPos ) const; \
  68         T& GetObject( USHORT nPos ); \
  69 \
  70         void Insert( USHORT nPos, ARR& rIns, USHORT nStart = 0, USHORT nEnd = USHRT_MAX );\
  71         void Insert( USHORT nPos, const T& rElem );\
  72         void Insert( USHORT nPos, const T& rElems, USHORT nLen );\
  73         void Append( const T& rElem );\
  74 \
  75         BOOL Remove( const T& rElem );\
  76         USHORT Remove( USHORT nPos, USHORT nLen );\
  77 \
  78         USHORT Count() const { return nUsed; }\
  79         T* operator*();\
  80         const T& operator[]( USHORT nPos ) const;\
  81         T& operator[]( USHORT nPos );\
  82 \
  83         BOOL Contains( const T& rItem ) const;\
  84         void Clear() { Remove( 0, Count() ); }\
  85 };\
  86 \
  87 inline void ARR::Insert( USHORT nPos, ARR& rIns, USHORT nStart, USHORT nEnd )\
  88 {\
  89         Insert( nPos, *(rIns.pData+(sizeof(T)*nStart)), nStart-nEnd+1 );\
  90 }\
  91 \
  92 inline void ARR::Insert( USHORT nPos, const T& rElem )\
  93 {\
  94         Insert( nPos, rElem, 1 );\
  95 }\
  96 \
  97 inline T* ARR::operator*()\
  98 {\
  99         return ( nUsed==0 ? 0 : pData );\
 100 } \
 101 inline const T& ARR::operator[]( USHORT nPos ) const\
 102 {\
 103     DBG_ASSERT( nPos < nUsed, "" ); \
 104     return *(pData+nPos);\
 105 } \
 106 inline T& ARR::operator [] (USHORT nPos) \
 107 {\
 108     DBG_ASSERT( nPos < nUsed, "" ); \
 109     return *(pData+nPos); \
 110 } \
 111 inline const T& ARR::GetObject( USHORT nPos ) const { return operator[](nPos); } \
 112 inline T& ARR::GetObject( USHORT nPos ) { return operator[](nPos); } \
 113
 114 #ifndef _lint
 115 // String too long
 116
 117 #define IMPL_OBJARRAY( ARR, T ) \
 118 ARR::ARR( BYTE nInitSize, BYTE nGrowSize ): \
 119         nUsed(0), \
 120         nUnused(nInitSize), \
 121         nGrow( nGrowSize ? nGrowSize : 1 ) \
 122 { \
 123         if ( nInitSize != 0 ) \
 124         { \
 125                 size_t nBytes = nInitSize * sizeof(T); \
 126                 pData = (T*) new char[ nBytes ]; \
 127                 memset( pData, 0, nBytes ); \
 128         } \
 129         else \
 130                 pData = 0; \
 131 } \
 132 \
 133 ARR::ARR( const ARR& rOrig ) \
 134 { \
 135         nUsed = rOrig.nUsed; \
 136         nGrow = rOrig.nGrow; \
 137         nUnused = rOrig.nUnused; \
 138 \
 139         if ( rOrig.pData != 0 ) \
 140         { \
 141                 size_t nBytes = (nUsed + nUnused) * sizeof(T); \
 142                 pData = (T*) new char [ nBytes ]; \
 143                 memset( pData, 0, nBytes ); \
 144         for ( USHORT n = 0; n < nUsed; ++n ) \
 145             *(pData+n) = *(rOrig.pData+n); \
 146         } \
 147         else \
 148                 pData = 0; \
 149 } \
 150 \
 151 ARR::~ARR() \
 152 { \
 153         for ( USHORT n = 0; n < nUsed; ++n ) \
 154                 ( pData+n )->T::~T(); \
 155         delete[] (char*) pData;\
 156 } \
 157 \
 158 ARR& ARR::operator= ( const ARR& rOrig )\
 159 { \
 160         for ( USHORT n = 0; n < nUsed; ++n ) \
 161                 ( pData+n )->T::~T(); \
 162     delete[] (char*) pData;\
 163 \
 164         nUsed = rOrig.nUsed; \
 165         nGrow = rOrig.nGrow; \
 166         nUnused = rOrig.nUnused; \
 167 \
 168         if ( rOrig.pData != 0 ) \
 169         { \
 170                 size_t nBytes = (nUsed + nUnused) * sizeof(T); \
 171                 pData = (T*) new char[ nBytes ]; \
 172                 memset( pData, 0, nBytes ); \
 173         for ( USHORT n = 0; n < nUsed; ++n ) \
 174             *(pData+n) = *(rOrig.pData+n); \
 175         } \
 176         else \
 177                 pData = 0; \
 178         return *this; \
 179 } \
 180 \
 181 void ARR::Append( const T& aElem ) \
 182 { \
 183          \
 184         if ( nUnused == 0 ) \
 185         { \
 186                 USHORT nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow; \
 187                 size_t nBytes = nNewSize * sizeof(T); \
 188                 T* pNewData = (T*) new char[ nBytes ]; \
 189                 memset( pNewData, 0, nBytes ); \
 190         if ( pData ) \
 191                 { \
 192                         memcpy( pNewData, pData, nUsed * sizeof(T) ); \
 193                         delete[] (char*) pData;\
 194                 } \
 195                 nUnused = (BYTE)(nNewSize-nUsed); \
 196                 pData = pNewData; \
 197         } \
 198 \
 199          \
 200         pData[nUsed] = aElem; \
 201         ++nUsed; \
 202         --nUnused; \
 203 } \
 204 \
 205 USHORT ARR::Remove( USHORT nPos, USHORT nLen ) \
 206 { \
 207         DBG_ASSERT( (nPos+nLen) < (nUsed+1), "" ); \
 208         DBG_ASSERT( nLen > 0, "" ); \
 209 \
 210         nLen = Min( (USHORT)(nUsed-nPos), (USHORT)nLen ); \
 211 \
 212         if ( nLen == 0 ) \
 213                 return 0; \
 214 \
 215         for ( USHORT n = nPos; n < (nPos+nLen); ++n ) \
 216                 ( pData+n )->T::~T(); \
 217 \
 218         if ( (nUsed-nLen) == 0 ) \
 219         { \
 220                 delete[] (char*) pData;\
 221                 pData = 0; \
 222                 nUsed = 0; \
 223                 nUnused = 0; \
 224                 return nLen; \
 225         } \
 226 \
 227         if ( (nUnused+nLen) >= nGrow ) \
 228         { \
 229                 USHORT nNewUsed = nUsed-nLen; \
 230                 USHORT nNewSize = (nNewUsed+nGrow-1)/nGrow; nNewSize *= nGrow; \
 231                 DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize, \
 232                                         "shrink size computation failed" ); \
 233                 size_t nBytes = nNewSize * sizeof(T); \
 234                 T* pNewData = (T*) new char[ nBytes ]; \
 235                 memset( pNewData, 0, nBytes ); \
 236                 if ( nPos > 0 ) \
 237                         memcpy( pNewData, pData, nPos * sizeof(T) ); \
 238                 if ( nNewUsed != nPos ) \
 239                         memcpy(pNewData+nPos, pData+nPos+nLen, (nNewUsed-nPos) * sizeof(T) ); \
 240                 delete[] (char*) pData;\
 241                 pData = pNewData; \
 242                 nUsed = nNewUsed; \
 243                 nUnused = (BYTE)(nNewSize - nNewUsed); \
 244                 return nLen; \
 245         } \
 246 \
 247          \
 248         if ( nUsed-nPos-nLen > 0 ) \
 249         { \
 250                 memmove(pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen) * sizeof(T));\
 251         } \
 252         nUsed -= (BYTE)nLen; \
 253         nUnused += (BYTE)nLen; \
 254         return nLen; \
 255 } \
 256 \
 257 BOOL ARR::Remove( const T& aElem ) \
 258 { \
 259         if ( nUsed == 0 ) \
 260                 return FALSE; \
 261 \
 262         const T *pIter = pData + nUsed - 1; \
 263         for ( USHORT n = 0; n < nUsed; ++n, --pIter ) \
 264                 if ( *pIter == aElem ) \
 265                 { \
 266                         Remove(nUsed-n-1, 1); \
 267                         return TRUE; \
 268                 } \
 269         return FALSE; \
 270 } \
 271 \
 272 BOOL ARR::Contains( const T& rItem ) const \
 273 { \
 274         if ( !nUsed ) \
 275                 return FALSE; \
 276         for ( USHORT n = 0; n < nUsed; ++n ) \
 277         { \
 278                 const T& r2ndItem = GetObject(n); \
 279                 if ( r2ndItem == rItem ) \
 280                         return TRUE; \
 281         } \
 282         return FALSE; \
 283 } \
 284 \
 285 void ARR::Insert( USHORT nPos, const T& rElems, USHORT nLen ) \
 286 { \
 287         DBG_ASSERT( nPos <= nUsed, "" ); \
 288          \
 289         if ( nUnused == 0 ) \
 290         { \
 291                 \
 292                 /* auf die naechste Grow-Grenze aufgerundet vergroeszern */ \
 293                 USHORT nNewSize; \
 294                 for ( nNewSize = nUsed+nGrow; nNewSize < (nUsed + nLen); ++nNewSize ) \
 295                         /* empty loop */; \
 296                 size_t nBytes = nNewSize * sizeof(T); \
 297                 T* pNewData = (T*) new char[ nBytes ]; \
 298                 memset( pNewData, 0, nBytes ); \
 299                 \
 300                 if ( pData ) \
 301                 { \
 302                         DBG_ASSERT( nUsed < nNewSize, "" ); \
 303                         memcpy( pNewData, pData, nUsed * sizeof(T) ); \
 304                         delete (char*) pData;\
 305                 } \
 306                 nUnused = (BYTE)(nNewSize-nUsed); \
 307                 pData = pNewData; \
 308         } \
 309 \
 310          \
 311         if ( nPos < nUsed ) \
 312         { \
 313         memmove(pData+nPos+nLen-1, pData+nPos-1, sizeof(T) * (nUsed-nPos));     \
 314         } \
 315 \
 316     memmove(pData+nPos, &rElems, sizeof(T) * nLen);     \
 317         nUsed += nLen; \
 318         nUnused -= nLen; \
 319 }
 320
 321 // _lint
 322 #endif
 323
 324 class SfxPtrArr
 325 {
 326 private:
 327         void** pData;
 328         USHORT nUsed;
 329         BYTE nGrow;
 330         BYTE nUnused;
 331 public:
 332         SfxPtrArr( BYTE nInitSize = 0, BYTE nGrowSize = 8 );
 333         SfxPtrArr( const SfxPtrArr& rOrig );
 334         ~SfxPtrArr();
 335         void* GetObject( USHORT nPos ) const { return operator[](nPos); }
 336         void*& GetObject( USHORT nPos ) { return operator[](nPos); }
 337         void Insert( USHORT nPos, void* rElem );
 338         BOOL Replace( void* pOldElem, void* pNewElem );
 339         BOOL Remove( void* rElem );
 340         USHORT Remove( USHORT nPos, USHORT nLen );
 341         USHORT Count() const { return nUsed; }
 342         inline void** operator*();
 343         inline void* operator[]( USHORT nPos ) const;
 344         inline void*& operator[]( USHORT nPos );
 345         void Clear() { Remove( 0, Count() ); }
 346 };
 347
 348 inline void** SfxPtrArr::operator*()
 349 {
 350         return ( nUsed==0 ? 0 : pData );
 351 }
 352
 353 inline void* SfxPtrArr::operator[]( USHORT nPos ) const
 354 {
 355         DBG_ASSERT( nPos < nUsed, "" );
 356         return *(pData+nPos);
 357 }
 358
 359 inline void*& SfxPtrArr::operator [] (USHORT nPos)
 360 {
 361         DBG_ASSERT( nPos < nUsed, "" );
 362         return *(pData+nPos);
 363 }
 364
 365 #define DECL_PTRARRAY(ARR, T, nI, nG)\
 366 class ARR: public SfxPtrArr\
 367 {\
 368 public:\
 369    ARR( BYTE nIni=nI, BYTE nGrow=nG ):\
 370            SfxPtrArr(nIni,nGrow) \
 371    {}\
 372    ARR( const ARR& rOrig ):\
 373            SfxPtrArr(rOrig) \
 374    {}\
 375    T GetObject( USHORT nPos ) const { return operator[](nPos); } \
 376    T& GetObject( USHORT nPos ) { return operator[](nPos); } \
 377    void Insert( USHORT nPos, T aElement ) {\
 378            SfxPtrArr::Insert(nPos,(void *)aElement);\
 379    }\
 380    BOOL Replace( T aOldElem, T aNewElem ) {\
 381        return SfxPtrArr::Replace((void *)aOldElem, (void*) aNewElem);\
 382    }\
 383    void Remove( T aElement ) {\
 384            SfxPtrArr::Remove((void*)aElement);\
 385    }\
 386    void Remove( USHORT nPos, USHORT nLen = 1 ) {\
 387            SfxPtrArr::Remove( nPos, nLen ); \
 388    }\
 389    T* operator *() {\
 390            return (T*) SfxPtrArr::operator*();\
 391    }\
 392    T operator[]( USHORT nPos ) const { \
 393            return (T) SfxPtrArr::operator[](nPos); } \
 394    T& operator[]( USHORT nPos ) { \
 395            return (T&) SfxPtrArr::operator[](nPos); } \
 396    void Clear() { Remove( 0, Count() ); }\
 397 };
 398
 399
 400
 401 #define DECL_1BYTEARRAY(ARR, T, nI, nG)\
 402 class ARR: public ByteArr\
 403 {\
 404 public:\
 405                 ARR( BYTE nIni=nI, BYTE nGrow=nG ):\
 406                         ByteArr(nIni,nGrow) \
 407                 {}\
 408                 ARR( const ARR& rOrig ):\
 409                         ByteArr(rOrig) \
 410                 {}\
 411                 T GetObject( USHORT nPos ) const { return operator[](nPos); } \
 412                 T& GetObject( USHORT nPos ) { return operator[](nPos); } \
 413                 void Insert( USHORT nPos, T aElement ) {\
 414                         ByteArr::Insert(nPos,(char)aElement);\
 415                 }\
 416                 void Append( T aElement ) {\
 417                         ByteArr::Append((char)aElement);\
 418                 }\
 419                 void Remove( T aElement ) {\
 420                         ByteArr::Remove((char)aElement);\
 421                 }\
 422                 void Remove( USHORT nPos, USHORT nLen = 1 ) {\
 423                         ByteArr::Remove( nPos, nLen ); \
 424                 }\
 425                 T* operator *() {\
 426                         return (T*) ByteArr::operator*();\
 427                 }\
 428                 T operator[]( USHORT nPos ) const { \
 429                         return (T) ByteArr::operator[](nPos); } \
 430                 T& operator[]( USHORT nPos ) { \
 431                         return (T&) ByteArr::operator[](nPos); } \
 432                 void Clear() { Remove( 0, Count() ); }\
 433 };
 434
 435 }//end of namespace binfilter
 436 #endif