configmgr/source/misc/bootstrapcontext.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: bootstrapcontext.cxx,v $
  10  * $Revision: 1.9 $
  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_configmgr.hxx"
  33
  34 #include "bootstrapcontext.hxx"
  35 #include "datalock.hxx"
  36 #include <uno/current_context.hxx>
  37 #include <cppuhelper/implbase2.hxx>
  38 #include <cppuhelper/exc_hlp.hxx>
  39 #include <cppuhelper/typeprovider.hxx>
  40 #include <com/sun/star/uno/XComponentContext.hpp>
  41 #include <com/sun/star/beans/XPropertySet.hpp>
  42 #include <com/sun/star/lang/DisposedException.hpp>
  43 #include "utility.hxx"
  44
  45 namespace configmgr
  46 {
  47 // ---------------------------------------------------------------------------
  48 #define IMPL_ITEM_PREFIX_     "/implementations/com.sun.star.com.configuration.bootstrap.ComponentContext/"
  49 #define IMPL_ITEM_PASSTHRU    IMPL_ITEM_PREFIX_"isPassthrough"
  50 #define IMPL_ITEM_BASECONTEXT IMPL_ITEM_PREFIX_"theBaseContext"
  51 #define A_SERVICEMANAGER "com.sun.star.lang.theServiceManager"
  52 // ---------------------------------------------------------------------------
  53
  54 #define OUSTR( text )     rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( text ) )
  55 #define OU2ASCII( str ) ( rtl::OUStringToOString(str,RTL_TEXTENCODING_ASCII_US) .getStr() )
  56 // ---------------------------------------------------------------------------
  57 #if 0
  58 static void testComplete()
  59 {
  60     uno::Reference< uno::XInterface > test = * new ComponentContext(uno::Reference< uno::XComponentContext >,uno::Sequence < beans::NamedValue >(),true);
  61 }
  62 #endif
  63 // ---------------------------------------------------------------------------
  64
  65 ComponentContext::ComponentContext(uno::Reference< uno::XComponentContext > const & _xContext)
  66 : cppu::WeakComponentImplHelper3 < uno::XComponentContext, uno::XCurrentContext, lang::XServiceInfo >(UnoApiLock::getLock())
  67 , m_xContext(_xContext)
  68 , m_hBootstrapData(NULL)
  69 , m_xServiceManager()
  70 {
  71 }
  72 // ---------------------------------------------------------------------------
  73
  74 ComponentContext::~ComponentContext()
  75 {
  76     if (m_hBootstrapData) rtl_bootstrap_args_close(m_hBootstrapData);
  77 }
  78 // ---------------------------------------------------------------------------
  79
  80 void ComponentContext::initialize( const rtl::OUString& _aURL )
  81 {
  82     UnoApiLock aLock;
  83
  84     OSL_ASSERT(!m_hBootstrapData);
  85     m_hBootstrapData = rtl_bootstrap_args_open(_aURL.pData);
  86
  87     uno::Reference< lang::XComponent > xOwner(m_xContext, uno::UNO_QUERY);
  88
  89     if (xOwner.is()) DisposingForwarder::forward(xOwner,this);
  90
  91     if (!m_xContext.is())
  92     {
  93         OSL_ENSURE(rBHelper.bDisposed,"ComponentContext::initialize - Context unexpectedly missing");
  94         throw lang::DisposedException(OUSTR("Parent context has been disposed early"),*this);
  95     }
  96 }
  97 // ---------------------------------------------------------------------------
  98
  99 // ComponentHelper
 100 void SAL_CALL ComponentContext::disposing()
 101 {
 102     UnoApiLock aLock;
 103
 104     m_xContext.clear();
 105
 106     if (m_hBootstrapData)
 107     {
 108         rtl_bootstrap_args_close(m_hBootstrapData);
 109         m_hBootstrapData = NULL;
 110     }
 111 }
 112 // ---------------------------------------------------------------------------
 113
 114 rtl::OUString ComponentContext::getBootstrapURL() const
 115 {
 116     rtl::OUString aResult;
 117
 118     UnoApiLock aLock;
 119
 120     if (m_hBootstrapData)
 121     {
 122         rtl_bootstrap_get_iniName_from_handle(m_hBootstrapData,&aResult.pData);
 123     }
 124     else
 125     {
 126         OSL_TRACE( "configmgr: No bootstrap data URL set");
 127     }
 128
 129     return aResult;
 130 }
 131 // ---------------------------------------------------------------------------
 132
 133 uno::Reference< lang::XMultiComponentFactory > SAL_CALL
 134     ComponentContext::getServiceManager(  )
 135         throw (uno::RuntimeException)
 136 {
 137     UnoApiLock aLock;
 138
 139     if (!m_xServiceManager.is())
 140     {
 141         uno::Reference< uno::XComponentContext > xBase = basecontext();
 142         if (!xBase.is())
 143             throw lang::DisposedException(OUSTR("Parent context has been disposed"),*this);
 144
 145         uno::Reference< lang::XMultiComponentFactory > xBaseServiceManager = xBase->getServiceManager();
 146         OSL_ENSURE( xBaseServiceManager.is(), "Base context has no service manager");
 147
 148         if (xBaseServiceManager.is())
 149         {
 150             // create new smgr based on delegate's one
 151             m_xServiceManager.set(
 152                 xBaseServiceManager->createInstanceWithContext( OUSTR("com.sun.star.comp.stoc.OServiceManagerWrapper"), xBase ),
 153                 uno::UNO_QUERY );
 154             // patch DefaultContext property of new one
 155             uno::Reference< beans::XPropertySet > xProps( m_xServiceManager, uno::UNO_QUERY );
 156             OSL_ASSERT( xProps.is() );
 157             if (xProps.is())
 158             {
 159                 uno::Reference< XComponentContext > xThis( this );
 160                 xProps->setPropertyValue( OUSTR("DefaultContext"), uno::makeAny( xThis ) );
 161             }
 162             else
 163                 OSL_ENSURE(!m_xServiceManager.is(), "Cannot set Default Context of Service Manager Wrapper: no property set");
 164         }
 165     }
 166     return m_xServiceManager;
 167 }
 168 // ---------------------------------------------------------------------------
 169
 170
 171 // ---------------------------------------------------------------------------
 172
 173 sal_Bool ComponentContext::isPassthrough(uno::Reference< uno::XComponentContext > const & _xContext)
 174 {
 175     OSL_ENSURE(_xContext.is(),"Unexpected NULL context");
 176     if (!_xContext.is()) return false;
 177
 178     sal_Bool bValue = false;
 179     _xContext->getValueByName(OUSTR(IMPL_ITEM_PASSTHRU)) >>= bValue;
 180     return bValue;
 181 }
 182 // ---------------------------------------------------------------------------
 183
 184 beans::NamedValue ComponentContext::makePassthroughMarker(sal_Bool bPassthrough)
 185 {
 186     return beans::NamedValue(OUSTR(IMPL_ITEM_PASSTHRU),uno::makeAny(bPassthrough));
 187 }
 188 // ---------------------------------------------------------------------------
 189
 190 bool ComponentContext::lookupInContext( uno::Any & _rValue, const rtl::OUString& _aName ) const
 191 {
 192     uno::Reference< uno::XComponentContext > xBase = basecontext();
 193     if (!xBase.is())
 194         throw lang::DisposedException(OUSTR("Parent context has been disposed"),const_cast<ComponentContext&>(*this));
 195
 196     if (_aName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM( IMPL_ITEM_BASECONTEXT )))
 197     {
 198         _rValue = uno::makeAny(xBase);
 199         return true;
 200     }
 201
 202     uno::Any aCtxValue = xBase->getValueByName( _aName );
 203
 204     if (aCtxValue.hasValue())
 205     {
 206         _rValue = aCtxValue;
 207         return true;
 208     }
 209     else
 210         return false;
 211 }
 212 // ---------------------------------------------------------------------------
 213
 214 bool ComponentContext::lookupInBootstrap( uno::Any & _rValue, const rtl::OUString& _aName ) const
 215 {
 216     UnoApiLock aLock;
 217     rtl::OUString sResult;
 218     if ( rtl_bootstrap_get_from_handle( m_hBootstrapData, _aName.pData, &sResult.pData, 0) )
 219     {
 220         _rValue <<= sResult;
 221         return true;
 222     }
 223     else
 224         return false;
 225 }
 226 // ---------------------------------------------------------------------------
 227 // ---------------------------------------------------------------------------
 228
 229 static const char k_TunneledContext[] = "/services/com.sun.star.configuration.bootstrap.Context";
 230
 231 class UnoContextTunnel::Tunnel
 232 : public ::cppu::WeakImplHelper2< uno::XCurrentContext, lang::XUnoTunnel >
 233 {
 234     uno::Reference< uno::XComponentContext >         m_xTunneledContext;
 235     uno::Reference< uno::XCurrentContext >  m_xOldContext;
 236     uno::Any        m_aFailure;
 237 public:
 238     Tunnel(uno::Reference< uno::XComponentContext > const & xTunneledContext, uno::Reference< uno::XCurrentContext > const & xOldContext)
 239     : m_xTunneledContext(xTunneledContext)
 240     , m_xOldContext(xOldContext)
 241     , m_aFailure()
 242     {}
 243
 244     virtual uno::Any SAL_CALL
 245         getValueByName( const rtl::OUString& name )
 246             throw (uno::RuntimeException)
 247     {
 248         if (name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(k_TunneledContext) ) )
 249         {
 250             return uno::makeAny(m_xTunneledContext);
 251         }
 252         else if (m_xOldContext.is())
 253         {
 254             return m_xOldContext->getValueByName(name);
 255         }
 256         else
 257         {
 258             return uno::Any();
 259         }
 260     }
 261
 262     virtual sal_Int64 SAL_CALL
 263         getSomething( const uno::Sequence< sal_Int8 >& aIdentifier )
 264             throw (uno::RuntimeException)
 265     {
 266         if (getTunnelId() == aIdentifier)
 267             return reinterpret_cast<sal_Int64>(&m_aFailure);
 268         else
 269             return 0;
 270     }
 271
 272     static uno::Any * getFailure(uno::Reference< lang::XUnoTunnel > const & xTunnel);
 273
 274     static uno::Sequence< sal_Int8 > getTunnelId();
 275 };
 276 // ---------------------------------------------------------------------------
 277
 278 uno::Sequence< sal_Int8 > UnoContextTunnel::Tunnel::getTunnelId()
 279 {
 280     static ::cppu::OImplementationId aTunnelId;
 281     return aTunnelId.getImplementationId();
 282 }
 283 // ---------------------------------------------------------------------------
 284
 285 uno::Any * UnoContextTunnel::Tunnel::getFailure(uno::Reference< lang::XUnoTunnel > const & xTunnel)
 286 {
 287     if (xTunnel.is())
 288     {
 289     if (sal_Int64 nSomething = xTunnel->getSomething(getTunnelId()))
 290     {
 291         return reinterpret_cast<uno::Any *>(nSomething);
 292     }
 293     }
 294     return NULL;
 295 }
 296 // ---------------------------------------------------------------------------
 297
 298 UnoContextTunnel::UnoContextTunnel()
 299 : m_xOldContext( uno::getCurrentContext() )
 300 , m_xActiveTunnel()
 301 {
 302 }
 303 // ---------------------------------------------------------------------------
 304
 305 UnoContextTunnel::~UnoContextTunnel()
 306 {
 307     uno::setCurrentContext( m_xOldContext );
 308 }
 309 // ---------------------------------------------------------------------------
 310
 311 void UnoContextTunnel::passthru(uno::Reference< uno::XComponentContext > const & xContext)
 312 {
 313     OSL_ASSERT( xContext.is() );
 314     if ( ComponentContext::isPassthrough(xContext) )
 315     {
 316         this ->tunnel(xContext);
 317     }
 318     else
 319     {
 320         this->tunnel(NULL);
 321     }
 322 }
 323 // ---------------------------------------------------------------------------
 324
 325 void UnoContextTunnel::tunnel(uno::Reference< uno::XComponentContext > const & xContext)
 326 {
 327     Tunnel * pNewTunnel = new Tunnel(xContext,m_xOldContext);
 328     m_xActiveTunnel = pNewTunnel;
 329     uno::setCurrentContext( pNewTunnel );
 330 }
 331 // ---------------------------------------------------------------------------
 332
 333 uno::Reference< uno::XComponentContext > UnoContextTunnel::recoverContext(uno::Reference< uno::XComponentContext > const & xFallback )
 334 {
 335     try
 336     {
 337         uno::Reference< uno::XCurrentContext > const xCurrContext = uno::getCurrentContext();
 338
 339         if (xCurrContext.is())
 340         {
 341             rtl::OUString aName(RTL_CONSTASCII_USTRINGPARAM(k_TunneledContext));
 342             uno::Reference< uno::XComponentContext > xResult;
 343             if (xCurrContext->getValueByName(aName) >>= xResult)
 344             {
 345                 if (xResult.is())
 346                     return xResult;
 347             }
 348             else
 349             {
 350                 OSL_ASSERT( !xResult.is() );
 351                 OSL_ENSURE( !xCurrContext->getValueByName(aName).hasValue(),
 352                             "Value in context has wrong type");
 353             }
 354         }
 355     }
 356     catch (uno::Exception &)
 357     {
 358         OSL_ENSURE(false, "Unexpected: Exception from accessing current context");
 359     }
 360
 361     return xFallback;
 362 }
 363 // ---------------------------------------------------------------------------
 364
 365 uno::Any UnoContextTunnel::recoverFailure(bool bRaise)
 366 {
 367     if (uno::Any * pFail = UnoContextTunnel::Tunnel::getFailure(m_xActiveTunnel))
 368     {
 369         if (bRaise)
 370         {
 371             if (pFail->hasValue())
 372                 cppu::throwException(*pFail);
 373             else
 374                 throw;
 375         }
 376         return *pFail;
 377     }
 378
 379     return uno::Any();
 380 }
 381 // ---------------------------------------------------------------------------
 382
 383 bool UnoContextTunnel::tunnelFailure(uno::Any const & aException, bool bRaise)
 384 {
 385     OSL_ASSERT( !aException.hasValue() || aException.getValueTypeClass() == uno::TypeClass_EXCEPTION );
 386
 387     uno::Reference< lang::XUnoTunnel > xTunnel( uno::getCurrentContext(), uno::UNO_QUERY );
 388
 389     if (uno::Any * pFail = Tunnel::getFailure(xTunnel))
 390     {
 391         *pFail = aException;
 392
 393         if (bRaise && aException.hasValue())
 394             cppu::throwException(aException);
 395
 396         if (bRaise) throw;
 397         return true;
 398     }
 399     else
 400     {
 401         if (bRaise) throw;
 402         return false;
 403     }
 404 }
 405 // ---------------------------------------------------------------------------
 406 // ---------------------------------------------------------------------------
 407 void DisposingForwarder::disposing( lang::EventObject const & /*rSource*/ )
 408 throw (uno::RuntimeException)
 409 {
 410     m_xTarget->dispose();
 411     m_xTarget.clear();
 412 }
 413 // ---------------------------------------------------------------------------
 414 // ---------------------------------------------------------------------------
 415 } // namespace config
 416
 417