sot/source/base/factory.cxx

   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: factory.cxx,v $
  10  * $Revision: 1.13 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sot.hxx"
  33
  34 #define _SOT_FACTORY_CXX
  35 #define SOT_STRING_LIST
  36
  37 #include <sot/factory.hxx>
  38 #include <tools/debug.hxx>
  39 #include <tools/string.hxx>
  40 #include <sot/object.hxx>
  41 #include <sot/sotdata.hxx>
  42 #include <clsids.hxx>
  43 #include <rtl/instance.hxx>
  44 #include <com/sun/star/datatransfer/DataFlavor.hpp>
  45
  46 /************** class SotData_Impl *********************************************/
  47 /*************************************************************************
  48 |*    SotData_Impl::SotData_Impl
  49 |*
  50 |*    Beschreibung
  51 *************************************************************************/
  52 SotData_Impl::SotData_Impl()
  53     : nSvObjCount( 0 )
  54     , pObjectList( NULL )
  55     , pFactoryList( NULL )
  56     , pSotObjectFactory( NULL )
  57     , pSotStorageStreamFactory( NULL )
  58     , pSotStorageFactory( NULL )
  59     , pDataFlavorList( NULL )
  60 {
  61 }
  62 /*************************************************************************
  63 |*    SOTDATA()
  64 |*
  65 |*    Beschreibung
  66 *************************************************************************/
  67 namespace { struct ImplData : public rtl::Static<SotData_Impl, ImplData> {}; }
  68 SotData_Impl * SOTDATA()
  69 {
  70     return &ImplData::get();
  71 }
  72
  73 /*************************************************************************
  74 |*    SotFactory::DeInit()
  75 |*
  76 |*    Beschreibung
  77 *************************************************************************/
  78 void SotFactory::DeInit()
  79 {
  80     SotData_Impl * pSotData = SOTDATA();
  81
  82     if( pSotData->nSvObjCount )
  83     {
  84 #ifdef DBG_UTIL
  85         ByteString aStr( "Objects alive: " );
  86         aStr.Append( ByteString::CreateFromInt32( pSotData->nSvObjCount ) );
  87         DBG_WARNING(  aStr.GetBuffer()  );
  88
  89 /*
  90         SotObjectList *pObjList = pSotData->pObjectList;
  91
  92         if( pObjList )
  93         {
  94             SotObject * p = pObjList->First();
  95             while( p )
  96             {
  97                 String aStr( "Factory: " );
  98                 aStr += p->GetSvFactory()->GetClassName();
  99                 aStr += " Count: ";
 100                 aStr += p->GetRefCount();
 101                 DBG_TRACE( "\tReferences:" );
 102                 p->TestObjRef( FALSE );
 103 #ifdef TEST_INVARIANT
 104                 DBG_TRACE( "\tInvariant:" );
 105                 p->TestInvariant( TRUE );
 106 #endif
 107                 p = pObjList->Next();
 108             }
 109         }
 110 */
 111 #endif
 112         return;
 113     }
 114
 115     // Muss von hinten nach vorne zerstoert werden. Das ist die umgekehrte
 116     // Reihenfolge der Erzeugung
 117     SotFactoryList* pFactoryList = pSotData->pFactoryList;
 118     if( pFactoryList )
 119     {
 120         SotFactory * pFact = pFactoryList->Last();
 121         while( NULL != (pFact = pFactoryList->Remove()) )
 122         {
 123             delete pFact;
 124             pFact = pFactoryList->Last();
 125         }
 126         delete pFactoryList;
 127         pSotData->pFactoryList = NULL;
 128     }
 129
 130     delete pSotData->pObjectList;
 131     pSotData->pObjectList = NULL;
 132     if( pSotData->pDataFlavorList )
 133     {
 134
 135         for( ULONG i = 0, nMax = pSotData->pDataFlavorList->Count(); i < nMax; i++ )
 136             delete (::com::sun::star::datatransfer::DataFlavor*) pSotData->pDataFlavorList->GetObject( i );
 137         delete pSotData->pDataFlavorList;
 138         pSotData->pDataFlavorList = NULL;
 139     }
 140     //delete pSOTDATA();
 141     //SOTDATA() = NULL;
 142 }
 143
 144
 145 /************** class SotFactory *****************************************/
 146 /*************************************************************************
 147 |*    SotFactory::SotFactory()
 148 |*
 149 |*    Beschreibung
 150 *************************************************************************/
 151 TYPEINIT0(SotFactory);
 152
 153 SotFactory::SotFactory( const SvGlobalName & rName,
 154                       const String & rClassName,
 155                       CreateInstanceType pCreateFuncP )
 156     : SvGlobalName  ( rName )
 157     , nSuperCount   ( 0 )
 158     , pSuperClasses ( NULL )
 159     , pCreateFunc   ( pCreateFuncP )
 160     , aClassName    ( rClassName )
 161 {
 162 #ifdef DBG_UTIL
 163     SvGlobalName aEmptyName;
 164     if( aEmptyName != *this )
 165     { // wegen Sfx-BasicFactories
 166     DBG_ASSERT( aEmptyName != *this, "create factory without SvGlobalName" );
 167     if( Find( *this ) )
 168     {
 169         /*
 170         String aStr( GetClassName() );
 171         aStr += ", UniqueName: ";
 172         aStr += GetHexName();
 173         aStr += ", create factories with the same unique name";
 174         DBG_ERROR( aStr );
 175         */
 176         DBG_ERROR( "create factories with the same unique name" );
 177     }
 178     }
 179 #endif
 180     SotData_Impl * pSotData = SOTDATA();
 181     if( !pSotData->pFactoryList )
 182         pSotData->pFactoryList = new SotFactoryList();
 183     // muss nach hinten, wegen Reihenfolge beim zerstoeren
 184     pSotData->pFactoryList->Insert( this, LIST_APPEND );
 185 }
 186
 187
 188 //=========================================================================
 189 SotFactory::~SotFactory()
 190 {
 191     delete [] pSuperClasses;
 192 }
 193
 194
 195 /*************************************************************************
 196 |*    SotFactory::
 197 |*
 198 |*    Beschreibung      Zugriffsmethoden auf SotData_Impl-Daten
 199 *************************************************************************/
 200 UINT32 SotFactory::GetSvObjectCount()
 201 {
 202     return SOTDATA()->nSvObjCount;
 203 }
 204
 205
 206 const SotFactoryList * SotFactory::GetFactoryList()
 207 {
 208     return SOTDATA()->pFactoryList;
 209 }
 210
 211 /*************************************************************************
 212 |*    SotFactory::Find()
 213 |*
 214 |*    Beschreibung
 215 *************************************************************************/
 216 const SotFactory* SotFactory::Find( const SvGlobalName & rFactName )
 217 {
 218     SvGlobalName aEmpty;
 219     SotData_Impl * pSotData = SOTDATA();
 220     if( rFactName != aEmpty && pSotData->pFactoryList )
 221     {
 222         SotFactory * pFact = pSotData->pFactoryList->First();
 223         while( pFact )
 224         {
 225             if( *pFact == rFactName )
 226                 return pFact;
 227             pFact = pSotData->pFactoryList->Next();
 228         }
 229     }
 230
 231     return 0;
 232 }
 233
 234 /*************************************************************************
 235 |*    SotFactory::PutSuperClass()
 236 |*
 237 |*    Beschreibung
 238 *************************************************************************/
 239 void SotFactory::PutSuperClass( const SotFactory * pFact )
 240 {
 241     nSuperCount++;
 242     if( !pSuperClasses )
 243         pSuperClasses = new const SotFactory * [ nSuperCount ];
 244     else
 245     {
 246         const SotFactory ** pTmp = new const SotFactory * [ nSuperCount ];
 247         memcpy( (void *)pTmp, (void *)pSuperClasses,
 248                 sizeof( void * ) * (nSuperCount -1) );
 249         delete [] pSuperClasses;
 250         pSuperClasses = pTmp;
 251     }
 252     pSuperClasses[ nSuperCount -1 ] = pFact;
 253 }
 254
 255
 256 /*************************************************************************
 257 |*    SotFactory::IncSvObjectCount()
 258 |*
 259 |*    Beschreibung
 260 *************************************************************************/
 261 void SotFactory::IncSvObjectCount( SotObject * pObj )
 262 {
 263     SotData_Impl * pSotData = SOTDATA();
 264     pSotData->nSvObjCount++;
 265     if( !pSotData->pObjectList )
 266         pSotData->pObjectList = new SotObjectList();
 267     if( pObj )
 268         pSotData->pObjectList->Insert( pObj );
 269 }
 270
 271
 272 /*************************************************************************
 273 |*    SotFactory::DecSvObjectCount()
 274 |*
 275 |*    Beschreibung
 276 *************************************************************************/
 277 void SotFactory::DecSvObjectCount( SotObject * pObj )
 278 {
 279     SotData_Impl * pSotData = SOTDATA();
 280     pSotData->nSvObjCount--;
 281     if( pObj )
 282         pSotData->pObjectList->Remove( pObj );
 283     if( !pSotData->nSvObjCount )
 284     {
 285         //keine internen und externen Referenzen mehr
 286     }
 287 }
 288
 289
 290 /*************************************************************************
 291 |*    SotFactory::TestInvariant()
 292 |*
 293 |*    Beschreibung
 294 *************************************************************************/
 295 void SotFactory::TestInvariant()
 296 {
 297 #ifdef TEST_INVARIANT
 298     SotData_Impl * pSotData = SOTDATA();
 299     if( pSotData->pObjectList )
 300     {
 301         ULONG nCount = pSotData->pObjectList->Count();
 302         for( ULONG i = 0; i < nCount ; i++ )
 303         {
 304             pSotData->pObjectList->GetObject( i )->TestInvariant( FALSE );
 305         }
 306     }
 307 #endif
 308 }
 309
 310 /*************************************************************************
 311 |*    SotFactory::CreateInstance()
 312 |*
 313 |*    Beschreibung
 314 *************************************************************************/
 315 void * SotFactory::CreateInstance( SotObject ** ppObj ) const
 316 {
 317     DBG_ASSERT( pCreateFunc, "SotFactory::CreateInstance: pCreateFunc == 0" );
 318     return pCreateFunc( ppObj );
 319 }
 320
 321 //=========================================================================
 322 void * SotFactory::CastAndAddRef
 323 (
 324     SotObject * pObj /* Das Objekt von dem der Typ gepr"uft wird. */
 325 ) const
 326 /*  [Beschreibung]
 327
 328     Ist eine Optimierung, damit die Ref-Klassen k"urzer implementiert
 329     werden k"onnen. pObj wird auf den Typ der Factory gecastet.
 330     In c++ (wenn es immer erlaubt w"are) w"urde der void * wie im
 331     Beispiel gebildet.
 332     Factory der Klasse SvPersist.
 333     void * p = (void *)(SvPersist *)pObj;
 334
 335     [R"uckgabewert]
 336
 337     void *,     NULL, pObj war NULL oder das Objekt war nicht vom Typ
 338                 der Factory.
 339                 Ansonsten wird pObj zuerst auf den Typ der Factory
 340                 gecastet und dann auf void *.
 341
 342     [Querverweise]
 343
 344     <SotObject::CastAndAddRef>
 345 */
 346 {
 347     return pObj ? pObj->CastAndAddRef( this ) : NULL;
 348 }
 349
 350 //=========================================================================
 351 void * SotFactory::AggCastAndAddRef
 352 (
 353     SotObject * pObj /* Das Objekt von dem der Typ gepr"uft wird. */
 354 ) const
 355 /*  [Beschreibung]
 356
 357     Ist eine Optimierung, damit die Ref-Klassen k"urzer implementiert
 358     werden k"onnen. pObj wird auf den Typ der Factory gecastet.
 359     In c++ (wenn es immer erlaubt w"are) w"urde der void * wie im
 360     Beispiel gebildet.
 361     Factory der Klasse SvPersist.
 362     void * p = (void *)(SvPersist *)pObj;
 363     Hinzu kommt noch, dass ein Objekt aus meheren c++ Objekten
 364     zusammengesetzt sein kann. Diese Methode sucht nach einem
 365     passenden Objekt.
 366
 367     [R"uckgabewert]
 368
 369     void *,     NULL, pObj war NULL oder das Objekt war nicht vom Typ
 370                 der Factory.
 371                 Ansonsten wird pObj zuerst auf den Typ der Factory
 372                 gecastet und dann auf void *.
 373
 374     [Querverweise]
 375
 376     <SvObject::AggCast>
 377 */
 378 {
 379     void * pRet = NULL;
 380     if( pObj )
 381     {
 382         pRet = pObj->AggCast( this );
 383         if( pRet )
 384             pObj->AddRef();
 385     }
 386     return pRet;
 387 }
 388
 389 /*************************************************************************
 390 |*    SotFactory::Is()
 391 |*
 392 |*    Beschreibung
 393 *************************************************************************/
 394 BOOL SotFactory::Is( const SotFactory * pSuperCl ) const
 395 {
 396     if( this == pSuperCl )
 397         return TRUE;
 398
 399     for( USHORT i = 0; i < nSuperCount; i++ )
 400     {
 401         if( pSuperClasses[ i ]->Is( pSuperCl ) )
 402             return TRUE;
 403     }
 404     return FALSE;
 405 }
 406
 407
 408
 409