binfilter/inc/bf_svtools/cntnrsrt.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: cntnrsrt.hxx,v $
  10  * $Revision: 1.3 $
  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 _CNTRSRT_HXX
  31 #define _CNTRSRT_HXX
  32
  33 #ifndef _CONTNR_HXX //autogen
  34 #include <tools/contnr.hxx>
  35 #endif
  36
  37 namespace binfilter {
  38
  39 #define DECLARE_CONTAINER_SORT_COMMON( ClassName, Type )                                                \
  40         ClassName( const ClassName& );                                                                                  \
  41     ClassName& operator =( const ClassName& );                                                          \
  42 public:                                                                                                 \
  43         using Container::Count;                                                                                 \
  44                                                                                                                                                         \
  45         ClassName( USHORT  InitSize, USHORT  ReSize ) :                                                 \
  46                 Container( CONTAINER_MAXBLOCKSIZE, InitSize, ReSize )   {}                      \
  47                                                                                                                                                         \
  48     BOOL Insert( Type* pObj );                                                                                          \
  49                                                                                                                                                         \
  50         Type *Remove( ULONG nPos )                                                                                              \
  51                 { return (Type *)Container::Remove( nPos ); }                                           \
  52                                                                                                                                                         \
  53         Type *Remove( Type* pObj );                                                                                             \
  54                                                                                                                                                         \
  55         void DeleteAndDestroy( ULONG nPos )                                                                             \
  56         {                                                                                                               \
  57                 Type *pObj = Remove( nPos );                                                                            \
  58                 if( pObj )                                                                                              \
  59                         delete pObj;                                                                                            \
  60         }                                                                                                               \
  61                                                                                                                                                         \
  62         void DeleteAndDestroy()                                                                                                 \
  63                 { while( Count() ) DeleteAndDestroy( 0 ); }                                                     \
  64                                                                                                                                                         \
  65     Type* GetObject( ULONG nPos ) const                                                                         \
  66                 { return (Type *)Container::GetObject( nPos ); }                                        \
  67                                                                                                                                                         \
  68         Type* operator[]( ULONG nPos ) const                                                                    \
  69                 { return GetObject(nPos); }                                                                                     \
  70                                                                                                                                                         \
  71         BOOL Seek_Entry( const Type *pObj, ULONG* pPos ) const;                                 \
  72                                                                                                                                                         \
  73         ULONG GetPos( const Type* pObj ) const;                                                                 \
  74
  75
  76 #define DECLARE_CONTAINER_SORT( ClassName, Type )                                                       \
  77 class ClassName : private Container                                                                                     \
  78 {                                                                                                                                                       \
  79         DECLARE_CONTAINER_SORT_COMMON( ClassName, Type )                                                \
  80         ~ClassName() {}                                                                                                                 \
  81 };                                                                                                                                                      \
  82
  83
  84 #define DECLARE_CONTAINER_SORT_DEL( ClassName, Type )                                                   \
  85 class ClassName : private Container                                                                                     \
  86 {                                                                                                                                                       \
  87         DECLARE_CONTAINER_SORT_COMMON( ClassName, Type )                                                        \
  88         ~ClassName() { DeleteAndDestroy(); }                                                                    \
  89 };                                                                                                                                                      \
  90
  91
  92 #define IMPL_CONTAINER_SORT( ClassName, Type, SortFunc )                                        \
  93 BOOL ClassName::Insert( Type *pObj )                                        \
  94 {                                                                           \
  95         ULONG nPos;                                                             \
  96         BOOL bExist = Seek_Entry( pObj, &nPos );                                \
  97         if( !bExist )                                                           \
  98                 Container::Insert( pObj, nPos );                                    \
  99         return !bExist;                                                         \
 100 }                                                                           \
 101                                                                                                                                                         \
 102 Type *ClassName::Remove( Type* pObj )                                       \
 103 {                                                                           \
 104         ULONG nPos;                                                             \
 105         if( Seek_Entry( pObj, &nPos ) )                                         \
 106                 return Remove( nPos );                                              \
 107         else                                                                    \
 108                 return 0;                                                           \
 109 }                                                                           \
 110                                                                                                                                                         \
 111 ULONG ClassName::GetPos( const Type* pObj ) const                           \
 112 {                                                                           \
 113         ULONG nPos;                                                             \
 114         if( Seek_Entry( pObj, &nPos ) )                                         \
 115                 return nPos;                                                        \
 116         else                                                                    \
 117                 return CONTAINER_ENTRY_NOTFOUND;                                    \
 118 }                                                                           \
 119                                                                                                                                                         \
 120 BOOL ClassName::Seek_Entry( const Type* pObj, ULONG* pPos ) const           \
 121 {                                                                           \
 122         register ULONG nO  = Count(),                                           \
 123                         nM,                                                             \
 124                         nU = 0;                                                         \
 125         if( nO > 0 )                                                            \
 126         {                                                                       \
 127                 nO--;                                                               \
 128                 while( nU <= nO )                                                   \
 129                 {                                                                   \
 130                         nM = nU + ( nO - nU ) / 2;                                      \
 131                         int nCmp = SortFunc( *GetObject(nM), *pObj );                               \
 132                                                                                                                                                         \
 133                         if( 0 == nCmp )                                                                 \
 134                         {                                                               \
 135                                 if( pPos ) *pPos = nM;                                      \
 136                                 return TRUE;                                                \
 137                         }                                                               \
 138                         else if( nCmp < 0 )                                                                     \
 139                                 nU = nM + 1;                                                \
 140                         else if( nM == 0 )                                              \
 141                         {                                                               \
 142                                 if( pPos ) *pPos = nU;                                      \
 143                                 return FALSE;                                               \
 144                         }                                                               \
 145                         else                                                            \
 146                                 nO = nM - 1;                                                \
 147                 }                                                                   \
 148         }                                                                       \
 149         if( pPos ) *pPos = nU;                                                  \
 150         return FALSE;                                                           \
 151 }                                                                           \
 152
 153 }
 154
 155 #endif