sw/inc/index.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: index.hxx,v $
  10  * $Revision: 1.10 $
  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 _INDEX_HXX
  31 #define _INDEX_HXX
  32
  33 #include <limits.h>
  34 #include <tools/solar.h>
  35 #include <tools/rtti.hxx>                               // for RTTI of SwIndexReg
  36 #include <tools/string.hxx>                             // for xub_StrLen
  37 #include <swdllapi.h>
  38
  39 #define INVALID_INDEX STRING_NOTFOUND
  40
  41 // Maximale Anzahl von Indizies im IndexArray (zum Abtesten auf Ueberlaeufe)
  42 class SwIndex;
  43 class SwIndexReg;
  44 struct SwPosition;
  45
  46 #ifdef PRODUCT
  47 #define INLINE inline
  48 #else
  49 #define INLINE
  50 #endif
  51
  52 class SW_DLLPUBLIC SwIndex
  53 {
  54     friend class SwIndexReg;
  55
  56 #ifndef PRODUCT
  57     static int nSerial;
  58     int MySerial;
  59 #endif
  60
  61     xub_StrLen  nIndex;
  62     SwIndexReg* pArray;
  63     SwIndex *pNext, *pPrev;
  64
  65     SwIndex& ChgValue( const SwIndex& rIdx, xub_StrLen nNewValue );
  66     void Remove();                                      // Ausketten
  67
  68 public:
  69     SwIndex( SwIndexReg * pReg, xub_StrLen nIdx = 0 );
  70     SwIndex( const SwIndex & );
  71     SwIndex( const SwIndex &, short nDiff );
  72     ~SwIndex() { Remove(); }
  73
  74     INLINE xub_StrLen operator++();
  75     INLINE xub_StrLen operator--();
  76 #ifndef CFRONT
  77     INLINE xub_StrLen operator++(int);
  78     INLINE xub_StrLen operator--(int);
  79 #endif
  80
  81     INLINE xub_StrLen operator+=( xub_StrLen );
  82     INLINE xub_StrLen operator-=( xub_StrLen );
  83     INLINE xub_StrLen operator+=( const SwIndex& );
  84     INLINE xub_StrLen operator-=( const SwIndex& );
  85
  86     INLINE BOOL operator<( const SwIndex& ) const;
  87     INLINE BOOL operator<=( const SwIndex& ) const;
  88     INLINE BOOL operator>( const SwIndex& ) const;
  89     INLINE BOOL operator>=( const SwIndex& ) const;
  90     BOOL operator==( const SwIndex& rSwIndex ) const
  91     { return (nIndex == rSwIndex.nIndex) &&  (pArray == rSwIndex.pArray); }
  92
  93     BOOL operator!=( const SwIndex& rSwIndex ) const
  94     { return (nIndex != rSwIndex.nIndex) ||  (pArray != rSwIndex.pArray); }
  95
  96     BOOL operator<( xub_StrLen nWert ) const    { return nIndex <  nWert; }
  97     BOOL operator<=( xub_StrLen nWert ) const   { return nIndex <= nWert; }
  98     BOOL operator>( xub_StrLen nWert ) const    { return nIndex >  nWert; }
  99     BOOL operator>=( xub_StrLen nWert ) const   { return nIndex >= nWert; }
 100     BOOL operator==( xub_StrLen nWert ) const   { return nIndex == nWert; }
 101     BOOL operator!=( xub_StrLen nWert ) const   { return nIndex != nWert; }
 102
 103     INLINE SwIndex& operator=( xub_StrLen );
 104     SwIndex& operator=( const SwIndex & );
 105
 106     // gebe den Wert vom Index als xub_StrLen zurueck
 107     xub_StrLen GetIndex() const { return nIndex; }
 108
 109     // ermoeglicht Zuweisungen ohne Erzeugen eines temporaeren
 110     // Objektes
 111     SwIndex &Assign(SwIndexReg *,xub_StrLen);
 112
 113         // Herausgabe des Pointers auf das IndexArray,
 114         // (fuers RTTI am SwIndexReg)
 115     const SwIndexReg* GetIdxReg() const { return pArray; }
 116 };
 117
 118 #undef INLINE
 119
 120 class SwIndexReg
 121 {
 122     friend class SwIndex;
 123     friend bool lcl_PosOk(const SwPosition & aPos);
 124
 125     const SwIndex *pFirst, *pLast, *pMiddle;
 126
 127     // ein globales Array, in das Indizies verschoben werden, die mal
 128     // temporaer "ausgelagert" werden muessen; oder die zum Zeitpunkt des
 129     // anlegens kein gueltiges Array kennen (SwPaM/SwPosition!)
 130     friend void _InitCore();
 131     friend void _FinitCore();
 132     static SwIndexReg* pEmptyIndexArray;
 133
 134 protected:
 135     virtual void Update( SwIndex const & rPos, const xub_StrLen nChangeLen,
 136                  const bool bNegative = false, const bool bDelete = false );
 137
 138     void ChkArr();
 139
 140     BOOL HasAnyIndex() const { return 0 != pFirst; }
 141
 142 public:
 143     SwIndexReg();
 144     virtual ~SwIndexReg();
 145
 146     // rtti, abgeleitete moegens gleichtun oder nicht. Wenn sie es gleichtun
 147     // kann ueber das SwIndexReg typsicher gecastet werden.
 148     TYPEINFO();
 149
 150     void MoveTo( SwIndexReg& rArr );
 151 };
 152
 153 #ifdef PRODUCT
 154
 155 inline xub_StrLen SwIndex::operator++()
 156 {
 157     return ChgValue( *this, nIndex+1 ).nIndex;
 158 }
 159 inline xub_StrLen SwIndex::operator--()
 160 {
 161     return ChgValue( *this, nIndex-1 ).nIndex;
 162 }
 163 #ifndef CFRONT
 164 inline xub_StrLen SwIndex::operator++(int)
 165 {
 166     xub_StrLen nOldIndex = nIndex;
 167     ChgValue( *this, nIndex+1 );
 168     return nOldIndex;
 169 }
 170 inline xub_StrLen SwIndex::operator--(int)
 171 {
 172     xub_StrLen nOldIndex = nIndex;
 173     ChgValue( *this, nIndex-1 );
 174     return nOldIndex;
 175 }
 176 #endif
 177
 178 inline xub_StrLen SwIndex::operator+=( xub_StrLen nWert )
 179 {
 180     return ChgValue( *this, nIndex + nWert ).nIndex;
 181 }
 182 inline xub_StrLen SwIndex::operator-=( xub_StrLen nWert )
 183 {
 184     return ChgValue( *this, nIndex - nWert ).nIndex;
 185 }
 186 inline xub_StrLen SwIndex::operator+=( const  SwIndex& rIndex )
 187 {
 188     return ChgValue( *this, nIndex + rIndex.nIndex ).nIndex;
 189 }
 190 inline xub_StrLen SwIndex::operator-=( const SwIndex& rIndex )
 191 {
 192     return ChgValue( *this, nIndex - rIndex.nIndex ).nIndex;
 193 }
 194
 195 inline BOOL SwIndex::operator<( const SwIndex& rIndex ) const
 196 {
 197     return nIndex < rIndex.nIndex;
 198 }
 199 inline BOOL SwIndex::operator<=( const SwIndex& rIndex ) const
 200 {
 201     return nIndex <= rIndex.nIndex;
 202 }
 203 inline BOOL SwIndex::operator>( const SwIndex& rIndex ) const
 204 {
 205     return nIndex > rIndex.nIndex;
 206 }
 207 inline BOOL SwIndex::operator>=( const SwIndex& rIndex ) const
 208 {
 209     return nIndex >= rIndex.nIndex;
 210 }
 211 inline SwIndex& SwIndex::operator=( xub_StrLen nWert )
 212 {
 213     if( nIndex != nWert )
 214         ChgValue( *this, nWert );
 215     return *this;
 216 }
 217
 218 #endif // PRODUCT
 219
 220 #endif