sc/source/filter/inc/namebuff.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: namebuff.hxx,v $
  10  * $Revision: 1.15.32.2 $
  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
  31 #ifndef SC_NAMEBUFF_HXX
  32 #define SC_NAMEBUFF_HXX
  33
  34 #include <tools/debug.hxx>
  35 #include <tools/string.hxx>
  36 #include "compiler.hxx"
  37 #include "root.hxx"
  38 #include "xiroot.hxx"
  39
  40 #include "rangenam.hxx"
  41 #include <hash_map>
  42 #include <list>
  43
  44 class ScDocument;
  45 class ScTokenArray;
  46 class NameBuffer;
  47
  48
  49
  50
  51 class StringHashEntry
  52 {
  53 private:
  54     friend class NameBuffer;
  55     String                      aString;
  56     UINT32                      nHash;
  57
  58     static UINT32       MakeHashCode( const String& );
  59 public:
  60     inline                      StringHashEntry( const String& );
  61     inline                      StringHashEntry( void );
  62     inline void         operator =(     const sal_Char* );
  63     inline void         operator =(     const String& );
  64     inline void         operator =( const StringHashEntry& );
  65     inline BOOL         operator ==( const StringHashEntry& ) const;
  66 };
  67
  68
  69 inline StringHashEntry::StringHashEntry( void )
  70 {
  71 }
  72
  73
  74 inline StringHashEntry::StringHashEntry( const String& r ) : aString( r )
  75 {
  76     nHash = MakeHashCode( r );
  77 }
  78
  79
  80 inline void StringHashEntry::operator =( const sal_Char* p )
  81 {
  82     aString.AssignAscii( p );
  83     nHash = MakeHashCode( aString );
  84 }
  85
  86
  87 inline void StringHashEntry::operator =( const String& r )
  88 {
  89     aString = r;
  90     nHash = MakeHashCode( r );
  91 }
  92
  93
  94 inline void StringHashEntry::operator =( const StringHashEntry& r )
  95 {
  96     nHash = r.nHash;
  97     aString = r.aString;
  98 }
  99
 100
 101 inline BOOL StringHashEntry::operator ==( const StringHashEntry& r ) const
 102 {
 103     return ( nHash == r.nHash && aString ==  r.aString );
 104 }
 105
 106
 107
 108 class NameBuffer : private List, public ExcRoot
 109 {
 110 private:
 111     UINT16                                      nBase;          // Index-Basis
 112 public:
 113 //    inline                  NameBuffer( void );   //#94039# prevent empty rootdata
 114     inline                                      NameBuffer( RootData* );
 115     inline                                      NameBuffer( RootData*, UINT16 nNewBase );
 116
 117     virtual                                     ~NameBuffer();
 118     inline const String*        Get( UINT16 nIndex );
 119     inline UINT16                       GetLastIndex( void );
 120     inline void                         SetBase( UINT16 nNewBase = 0 );
 121     void                                        operator <<( const String& rNewString );
 122 };
 123
 124 //#94039# prevent empty rootdata
 125 //inline NameBuffer::NameBuffer( void )
 126 //{
 127 //    nBase = 0;
 128 //}
 129
 130
 131 inline NameBuffer::NameBuffer( RootData* p ) : ExcRoot( p )
 132 {
 133     nBase = 0;
 134 }
 135
 136
 137 inline NameBuffer::NameBuffer( RootData* p, UINT16 nNewBase ) : ExcRoot( p )
 138 {
 139     nBase = nNewBase;
 140 }
 141
 142
 143 inline const String* NameBuffer::Get( UINT16 n )
 144 {
 145     if( n < nBase )
 146         return NULL;
 147     else
 148     {
 149         StringHashEntry* pObj = ( StringHashEntry* ) List::GetObject( n );
 150
 151         if( pObj )
 152             return &pObj->aString;
 153         else
 154             return NULL;
 155     }
 156 }
 157
 158
 159 inline UINT16 NameBuffer::GetLastIndex( void )
 160 {
 161     DBG_ASSERT( Count() + nBase <= 0xFFFF, "*NameBuffer::GetLastIndex(): Ich hab' die Nase voll!" );
 162
 163     return ( UINT16 ) ( Count() + nBase );
 164 }
 165
 166
 167 inline void NameBuffer::SetBase( UINT16 nNewBase )
 168 {
 169     nBase = nNewBase;
 170 }
 171
 172
 173
 174
 175 class ShrfmlaBuffer : public ExcRoot
 176 {
 177     struct ScAddressHashFunc : public std::unary_function< const ScAddress &, size_t >
 178     {
 179         size_t operator() (const ScAddress &addr) const;
 180     };
 181     typedef std::hash_map <ScAddress, USHORT, ScAddressHashFunc> ShrfmlaHash;
 182     typedef     std::list <ScRange>                                                                      ShrfmlaList;
 183
 184     ShrfmlaHash  index_hash;
 185     ShrfmlaList  index_list;
 186     size_t                  mnCurrIdx;
 187
 188 public:
 189                             ShrfmlaBuffer( RootData* pRD );
 190     virtual                                     ~ShrfmlaBuffer();
 191     void                    Clear();
 192     void                                        Store( const ScRange& rRange, const ScTokenArray& );
 193     USHORT                  Find (const ScAddress & rAddress ) const;
 194
 195     static String                       CreateName( const ScRange& );
 196     };
 197
 198
 199
 200
 201 class RangeNameBufferWK3 : private List
 202 {
 203 private:
 204     struct ENTRY
 205         {
 206         StringHashEntry         aStrHashEntry;
 207         ScComplexRefData                aScComplexRefDataRel;
 208         String                          aScAbsName;
 209         UINT16                          nAbsInd;                // == 0 -> noch keine Abs-Name!
 210         UINT16                          nRelInd;
 211         BOOL                            bSingleRef;
 212                             ENTRY( const String& rName, const String& rScName, const ScComplexRefData& rCRD ) :
 213                                 aStrHashEntry( rName ),
 214                                 aScComplexRefDataRel( rCRD ),
 215                                 aScAbsName( rScName )
 216                             {
 217                                 nAbsInd = 0;
 218                                 aScAbsName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "_ABS" ) );
 219                             }
 220         };
 221
 222     ScTokenArray*                       pScTokenArray;
 223     UINT16                                      nIntCount;
 224 public:
 225                             RangeNameBufferWK3( void );
 226     virtual                                     ~RangeNameBufferWK3();
 227     void                                        Add( const String& rName, const ScComplexRefData& rCRD );
 228     inline void                         Add( const String& rName, const ScRange& aScRange );
 229     BOOL                                        FindRel( const String& rRef, UINT16& rIndex );
 230     BOOL                                        FindAbs( const String& rRef, UINT16& rIndex );
 231 };
 232
 233
 234 inline void RangeNameBufferWK3::Add( const String& rName, const ScRange& aScRange )
 235 {
 236     ScComplexRefData            aCRD;
 237     ScSingleRefData*            pSRD;
 238     const ScAddress*    pScAddr;
 239
 240     pSRD = &aCRD.Ref1;
 241     pScAddr = &aScRange.aStart;
 242     pSRD->SetFlag3D( TRUE );
 243     pSRD->nCol = pScAddr->Col();
 244     pSRD->nRow = pScAddr->Row();
 245     pSRD->nTab = pScAddr->Tab();
 246
 247     // zunaechst ALLE Refs nur absolut
 248     pSRD->SetColRel( FALSE );
 249     pSRD->SetRowRel( FALSE );
 250     pSRD->SetTabRel( FALSE );
 251
 252     pSRD = &aCRD.Ref2;
 253     pScAddr = &aScRange.aEnd;
 254     pSRD->SetFlag3D( TRUE );
 255     pSRD->nCol = pScAddr->Col();
 256     pSRD->nRow = pScAddr->Row();
 257     pSRD->nTab = pScAddr->Tab();
 258
 259     // zunaechst ALLE Refs nur absolut
 260     pSRD->SetColRel( FALSE );
 261     pSRD->SetRowRel( FALSE );
 262     pSRD->SetTabRel( FALSE );
 263
 264     Add( rName, aCRD );
 265 }
 266
 267
 268
 269
 270 class ExtSheetBuffer : private List, public ExcRoot
 271 {
 272 private:
 273     struct Cont
 274         {
 275         String          aFile;
 276         String          aTab;
 277         UINT16          nTabNum;        // 0xFFFF -> noch nicht angelegt
 278                                 // 0xFFFE -> versucht anzulegen, ging aber schief
 279                                 // 0xFFFD -> soll im selben Workbook sein, findet's aber nicht
 280         BOOL            bSWB;
 281         BOOL            bLink;
 282                     Cont( const String& rFilePathAndName, const String& rTabName ) :
 283                         aFile( rFilePathAndName ),
 284                         aTab( rTabName )
 285                     {
 286                         nTabNum = 0xFFFF;       // -> Tabelle noch nicht erzeugt
 287                         bSWB = bLink = FALSE;
 288                     }
 289                     Cont( const String& rFilePathAndName, const String& rTabName,
 290                         const BOOL bSameWB ) :
 291                         aFile( rFilePathAndName ),
 292                         aTab( rTabName )
 293                     {
 294                         nTabNum = 0xFFFF;       // -> Tabelle noch nicht erzeugt
 295                         bSWB = bSameWB;
 296                         bLink = FALSE;
 297                     }
 298         };
 299 public:
 300     inline                      ExtSheetBuffer( RootData* );
 301     virtual                     ~ExtSheetBuffer();
 302
 303     sal_Int16       Add( const String& rFilePathAndName,
 304                         const String& rTabName, const BOOL bSameWorkbook = FALSE );
 305
 306     BOOL                        GetScTabIndex( UINT16 nExcSheetIndex, UINT16& rIn_LastTab_Out_ScIndex );
 307     BOOL                        IsLink( const UINT16 nExcSheetIndex ) const;
 308     BOOL                        GetLink( const UINT16 nExcSheetIndex, String &rAppl, String &rDoc ) const;
 309
 310     void                        Reset( void );
 311 };
 312
 313
 314 inline ExtSheetBuffer::ExtSheetBuffer( RootData* p ) : ExcRoot( p )
 315 {
 316 }
 317
 318
 319
 320
 321 struct ExtName
 322 {
 323     String                      aName;
 324     UINT32                      nStorageId;
 325     UINT16                      nFlags;
 326
 327     inline          ExtName( const String& r, sal_uInt16 n ) : aName( r ), nStorageId( 0 ), nFlags( n ) {}
 328
 329     BOOL                        IsDDE( void ) const;
 330     BOOL            IsOLE( void ) const;
 331 };
 332
 333
 334
 335
 336 class ExtNameBuff : protected XclImpRoot
 337 {
 338 public:
 339     explicit        ExtNameBuff( const XclImpRoot& rRoot );
 340
 341     void            AddDDE( const String& rName, sal_Int16 nRefIdx );
 342     void            AddOLE( const String& rName, sal_Int16 nRefIdx, UINT32 nStorageId );
 343     void            AddName( const String& rName, sal_Int16 nRefIdx );
 344
 345     const ExtName*  GetNameByIndex( sal_Int16 nRefIdx, sal_uInt16 nNameIdx ) const;
 346
 347     void            Reset();
 348
 349 private:
 350     typedef ::std::vector< ExtName >            ExtNameVec;
 351     typedef ::std::map< sal_Int16, ExtNameVec > ExtNameMap;
 352
 353     ExtNameMap      maExtNames;
 354 };
 355
 356
 357 #endif
 358
 359