bridges/source/remote/context/context.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: context.cxx,v $
  10  * $Revision: 1.12 $
  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_bridges.hxx"
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <list>
  36 #include <hash_map>
  37 #include <utility>
  38
  39 #include <osl/diagnose.h>
  40 #include <osl/interlck.h>
  41 #include <osl/mutex.hxx>
  42
  43 #include "rtl/ustring.hxx"
  44
  45 #include <bridges/remote/context.h>
  46 #include <bridges/remote/remote.h>
  47 #include <bridges/remote/connection.h>
  48 #include <bridges/remote/counter.hxx>
  49
  50 using namespace ::std;
  51 using namespace ::osl;
  52 using namespace ::rtl;
  53
  54 namespace {
  55
  56 extern "C" typedef void * (SAL_CALL * MemAlloc)(sal_Size);
  57
  58 }
  59
  60 namespace remote_context
  61 {
  62
  63 class remote_ContextImpl :
  64     public remote_Context
  65 {
  66 public:
  67     remote_ContextImpl( remote_Connection *pConnection,
  68                         rtl_uString *pIdStr,
  69                         rtl_uString *pDescription,
  70                         rtl_uString *pProtocol,
  71                         remote_InstanceProvider *pProvider );
  72     ~remote_ContextImpl();
  73
  74     static void SAL_CALL thisAcquire( uno_Context * );
  75     static void SAL_CALL thisRelease( uno_Context * );
  76     static void * SAL_CALL thisQuery( uno_Context * , rtl_uString * );
  77     static void SAL_CALL thisAddDisposingListener( remote_Context * , remote_DisposingListener * );
  78     static void SAL_CALL thisRemoveDisposingListener( remote_Context *, remote_DisposingListener *);
  79     static void SAL_CALL thisDispose( remote_Context *);
  80 public:
  81     oslInterlockedCount m_nRef;
  82     sal_Bool m_bDisposed;
  83     list < remote_DisposingListener * > m_lstListener;
  84     Mutex m_mutex;
  85 };
  86
  87
  88
  89
  90 struct equalOUString_Impl
  91 {
  92     sal_Bool operator()(const OUString & s1, const OUString & s2) const
  93         { return s1 == s2; }
  94 };
  95
  96 struct hashOUString_Impl
  97 {
  98     size_t operator()(const OUString & rName) const
  99         { return rName.hashCode(); }
 100 };
 101
 102 typedef hash_map
 103 <
 104     OUString,
 105     void *,
 106     hashOUString_Impl,
 107     equalOUString_Impl
 108 >
 109 ContextMap;
 110
 111 #if OSL_DEBUG_LEVEL > 1
 112 static MyCounter thisCounter( "DEBUG : Context" );
 113 #endif
 114
 115 class ContextAdmin;
 116
 117 ContextAdmin *g_pTheContext = 0;
 118
 119
 120
 121 class ContextAdmin
 122 {
 123 public:
 124     static ContextAdmin *getInstance();
 125
 126     // listener administration
 127     void addContextListener( remote_contextListenerFunc listener , void *pObject );
 128     void removeContextListener( remote_contextListenerFunc listener , void *pObject );
 129
 130     void fire( sal_Int32 nRemoteContextMode,
 131                rtl_uString *sName,
 132                rtl_uString *sDescription );
 133
 134     // context administration
 135     uno_Context *createAndRegisterContext(
 136         remote_Connection *pConnection,
 137         rtl_uString *pIdStr,
 138         rtl_uString *pDescription,
 139         rtl_uString *pProtocol,
 140         remote_InstanceProvider *pInstanceProvider );
 141
 142     void revokeContext( uno_Context *pRemoteContext );
 143
 144     uno_Context *get( rtl_uString *pHost );
 145
 146     rtl_uString ** getConnectionList(
 147         sal_Int32 *pnStringCount, MemAlloc memAlloc );
 148
 149 private:
 150     ::osl::Mutex          m_mutex;
 151
 152     ContextMap m_mapContext;
 153
 154     typedef std::list< std::pair< remote_contextListenerFunc, void * > > List;
 155     List m_lstListener;
 156 };
 157
 158 ContextAdmin *ContextAdmin::getInstance()
 159 {
 160     if( ! g_pTheContext ) {
 161         ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() );
 162         if( ! g_pTheContext ) {
 163             //TODO  This memory is leaked; see #i63473# for when this should be
 164             // changed again:
 165             g_pTheContext = new ContextAdmin;
 166         }
 167     }
 168     return g_pTheContext;
 169 }
 170
 171 void ContextAdmin::addContextListener( remote_contextListenerFunc listener , void  *pObject )
 172 {
 173     ::osl::MutexGuard guard( m_mutex );
 174
 175     m_lstListener.push_back( std::make_pair( listener, pObject ) );
 176 }
 177
 178 void ContextAdmin::removeContextListener( remote_contextListenerFunc listener , void *pObject )
 179 {
 180     ::osl::MutexGuard guard( m_mutex );
 181
 182     for (List::iterator ii(m_lstListener.begin()); ii != m_lstListener.end();
 183          ++ii)
 184     {
 185         if (ii->first == listener && ii->second == pObject) {
 186             m_lstListener.erase( ii );
 187             break;
 188         }
 189     }
 190 }
 191
 192 void ContextAdmin::fire(
 193     sal_Int32 nRemoteContextMode,
 194     rtl_uString *pName,
 195     rtl_uString *sDescription )
 196 {
 197     List lst;
 198     {
 199         ::osl::MutexGuard guard( m_mutex );
 200         lst = m_lstListener;
 201     }
 202     for (List::iterator i(lst.begin()); i != lst.end(); ++i) {
 203         (i->first)(i->second, nRemoteContextMode, pName, sDescription);
 204     }
 205 }
 206
 207 uno_Context *ContextAdmin::createAndRegisterContext( remote_Connection *pConnection,
 208                                                      rtl_uString *pIdStr,
 209                                                      rtl_uString *pDescription,
 210                                                      rtl_uString *pProtocol,
 211                                                      remote_InstanceProvider *pInstanceProvider )
 212 {
 213     ::osl::MutexGuard guard( m_mutex );
 214
 215     uno_Context *pContext = get( pIdStr );
 216     if( pContext )
 217     {
 218         pContext->release( pContext );
 219         return 0;
 220     }
 221
 222     remote_ContextImpl *p = new remote_ContextImpl( pConnection,
 223                                                     pIdStr,
 224                                                     pDescription,
 225                                                     pProtocol,
 226                                                     pInstanceProvider );
 227
 228     p->aBase.acquire( (uno_Context*) p );
 229
 230     m_mapContext[ OUString( pIdStr) ] = (void*) p;
 231
 232     fire( REMOTE_CONTEXT_CREATE , pIdStr , pDescription );
 233     return ( uno_Context * )p;
 234 }
 235
 236
 237 void ContextAdmin::revokeContext( uno_Context *pRemoteContext )
 238 {
 239     ::osl::MutexGuard guard( m_mutex );
 240
 241     remote_ContextImpl *p = ( remote_ContextImpl * ) pRemoteContext;
 242
 243     ContextMap::iterator ii = m_mapContext.find(  p->m_pName );
 244     OSL_ASSERT( ii != m_mapContext.end() );
 245     m_mapContext.erase( ii );
 246
 247     fire( REMOTE_CONTEXT_DESTROY , p->m_pName , p->m_pDescription );
 248
 249 }
 250
 251 uno_Context *ContextAdmin::get( rtl_uString *pHost )
 252 {
 253     ::osl::MutexGuard guard( m_mutex );
 254
 255     ContextMap::iterator ii = m_mapContext.find( OUString( (rtl_uString*)pHost ) );
 256     if( ii == m_mapContext.end() )
 257     {
 258         return 0;
 259     }
 260
 261     uno_Context *p =  ( uno_Context * ) (*ii).second;
 262     p->acquire( p );
 263     return p;
 264 }
 265
 266
 267 rtl_uString ** ContextAdmin::getConnectionList(
 268     sal_Int32 *pnStringCount, MemAlloc memAlloc )
 269 {
 270     ::osl::MutexGuard guard( m_mutex );
 271
 272     *pnStringCount = m_mapContext.size();
 273     rtl_uString **ppReturn = ( rtl_uString ** )
 274         memAlloc( sizeof( rtl_uString * ) * m_mapContext.size() );
 275     memset( ppReturn , 0 , sizeof( rtl_uString * ) * m_mapContext.size() );
 276
 277     sal_Int32 i = 0;
 278     for( ContextMap::iterator ii = m_mapContext.begin() ;
 279          ii != m_mapContext.end();
 280          ++ii, i++ )
 281     {
 282         rtl_uString_assign( &( ppReturn[i] ), (*ii).first.pData  );
 283     }
 284
 285     return ppReturn;
 286 }
 287
 288
 289
 290 /*****************************
 291  * remote_ContextImpl implementation
 292  ****************************/
 293
 294
 295
 296 remote_ContextImpl::remote_ContextImpl( remote_Connection *pConnection ,
 297                                         rtl_uString *pIdStr,
 298                                         rtl_uString *pDescription,
 299                                         rtl_uString *pProtocol,
 300                                         remote_InstanceProvider *pProvider ) :
 301     m_nRef( 0 ),
 302     m_bDisposed( sal_False )
 303 {
 304     m_pConnection = pConnection;
 305     m_pConnection->acquire( m_pConnection );
 306
 307     m_pInstanceProvider = pProvider;
 308     if( m_pInstanceProvider )
 309     {
 310         m_pInstanceProvider->acquire( pProvider );
 311     }
 312
 313     m_pName = pIdStr;
 314     rtl_uString_acquire( m_pName );
 315
 316     m_pDescription = pDescription;
 317     rtl_uString_acquire( m_pDescription );
 318
 319     m_pProtocol = pProtocol;
 320     rtl_uString_acquire( pProtocol );
 321
 322     aBase.acquire = thisAcquire;
 323     aBase.release = thisRelease;
 324     addDisposingListener = thisAddDisposingListener;
 325     removeDisposingListener = thisRemoveDisposingListener;
 326     dispose = thisDispose;
 327 #if OSL_DEBUG_LEVEL > 1
 328     thisCounter.acquire();
 329 #endif
 330 }
 331
 332 remote_ContextImpl::~remote_ContextImpl()
 333 {
 334     // disposed must have been called
 335     OSL_ASSERT( m_bDisposed );
 336
 337     rtl_uString_release( m_pName );
 338     rtl_uString_release( m_pDescription );
 339     rtl_uString_release( m_pProtocol );
 340 #if OSL_DEBUG_LEVEL > 1
 341     thisCounter.release();
 342 #endif
 343
 344 }
 345
 346
 347 void remote_ContextImpl::thisAddDisposingListener( remote_Context *pRemoteC ,
 348                                                    remote_DisposingListener *pListener )
 349 {
 350     remote_ContextImpl *pImpl = (remote_ContextImpl * ) pRemoteC;
 351
 352     ::osl::MutexGuard guard( pImpl->m_mutex );
 353
 354     pListener->acquire( pListener );
 355     pImpl->m_lstListener.push_back( pListener );
 356 }
 357
 358 void remote_ContextImpl::thisRemoveDisposingListener( remote_Context *pRemoteC,
 359                                                       remote_DisposingListener *pListener)
 360 {
 361     remote_ContextImpl *pImpl = (remote_ContextImpl * ) pRemoteC;
 362     MutexGuard guard( pImpl->m_mutex );
 363
 364     for( list< remote_DisposingListener * >::iterator ii = pImpl->m_lstListener.begin() ;
 365          ii != pImpl->m_lstListener.end();
 366          ++ii )
 367     {
 368         if( (*ii) == pListener  )
 369         {
 370             pImpl->m_lstListener.erase( ii );
 371             pListener->release( pListener );
 372             break;
 373         }
 374     }
 375 }
 376
 377 void remote_ContextImpl::thisDispose( remote_Context *pRemoteC )
 378 {
 379     remote_ContextImpl *pImpl = ( remote_ContextImpl * )pRemoteC;
 380
 381     MutexGuard guard( pImpl->m_mutex );
 382     if( ! pImpl->m_bDisposed )
 383     {
 384         pImpl->m_bDisposed = sal_True;
 385         ContextAdmin::getInstance()->revokeContext( (uno_Context * )  pRemoteC );
 386
 387         if( pImpl->m_pInstanceProvider )
 388         {
 389             pImpl->m_pInstanceProvider->release( pImpl->m_pInstanceProvider );
 390             pImpl->m_pInstanceProvider = 0;
 391         }
 392
 393         pImpl->m_pConnection->release( pImpl->m_pConnection );
 394         pImpl->m_pConnection = 0;
 395
 396         list< remote_DisposingListener * > lst = pImpl->m_lstListener;
 397         pImpl->m_lstListener.clear();
 398
 399         for( list < remote_DisposingListener * >::iterator ii = lst.begin();
 400              ii != lst.end();
 401              ++ii )
 402         {
 403             (*ii)->disposing( (*ii) , pImpl->m_pName );
 404             (*ii)->release( (*ii) );
 405         }
 406
 407     }
 408 }
 409
 410
 411
 412 void remote_ContextImpl::thisAcquire( uno_Context *pRemoteC )
 413 {
 414     remote_ContextImpl *p = SAL_REINTERPRET_CAST(remote_ContextImpl * ,pRemoteC );
 415     osl_incrementInterlockedCount( &(p->m_nRef) );
 416 }
 417
 418 void remote_ContextImpl::thisRelease( uno_Context *pRemoteC )
 419 {
 420     remote_ContextImpl *p = SAL_REINTERPRET_CAST( remote_ContextImpl * , pRemoteC );
 421     if (! osl_decrementInterlockedCount( &(p->m_nRef) ))
 422     {
 423         // enshure, that this piece of code is not reentered
 424         osl_incrementInterlockedCount( &(p->m_nRef) );
 425
 426         // dispose, if necessary
 427         p->dispose( p );
 428
 429         // restore the counter
 430         osl_decrementInterlockedCount( &(p->m_nRef) );
 431
 432         if( 0 == p->m_nRef )
 433         {
 434             delete p;
 435         }
 436         else
 437         {
 438             // reanimated, but disposed !
 439         }
 440     }
 441 }
 442
 443 void *remote_ContextImpl::thisQuery( uno_Context * , rtl_uString * )
 444 {
 445     return 0;
 446 }
 447
 448
 449 } // end namespace remote_context
 450
 451
 452 using namespace remote_context;
 453
 454 //-----------------------
 455 //
 456 // C-Interface
 457 //
 458 //-----------------------
 459 extern "C" remote_Context * SAL_CALL
 460 remote_getContext( rtl_uString *pIdString )
 461 {
 462     return (remote_Context *) ContextAdmin::getInstance()->get(  pIdString );
 463 }
 464
 465
 466
 467 extern "C" remote_Context * SAL_CALL
 468 remote_createContext( remote_Connection *pConnection,
 469                       rtl_uString *pIdStr,
 470                       rtl_uString *pDescription,
 471                       rtl_uString *pProtocol,
 472                       remote_InstanceProvider *pProvider )
 473 {
 474     remote_ContextImpl *p = (remote_ContextImpl * )
 475         ContextAdmin::getInstance()->createAndRegisterContext(
 476             pConnection ,
 477             pIdStr ,
 478             pDescription,
 479             pProtocol,
 480             pProvider );
 481
 482     return (remote_Context * )p;
 483 }
 484
 485
 486 extern "C" void SAL_CALL
 487 remote_addContextListener( remote_contextListenerFunc listener,  void *pObject )
 488 {
 489     ContextAdmin::getInstance()->addContextListener( listener , pObject );
 490 }
 491
 492 extern "C" void SAL_CALL
 493 remote_removeContextListener( remote_contextListenerFunc listener , void *pObject )
 494 {
 495     ContextAdmin::getInstance()->removeContextListener( listener , pObject );
 496 }
 497
 498 extern "C" rtl_uString ** SAL_CALL
 499 remote_getContextList( sal_Int32 *pnStringCount, MemAlloc memAlloc )
 500 {
 501     return ContextAdmin::getInstance()->getConnectionList( pnStringCount , memAlloc );
 502 }