cppuhelper/source/stdidlclass.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: stdidlclass.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_cppuhelper.hxx"
  33
  34 #include <osl/mutex.hxx>
  35
  36 #include <cppuhelper/weakref.hxx>
  37 #include <cppuhelper/weak.hxx>
  38 #include <cppuhelper/stdidlclass.hxx>
  39
  40 #include <com/sun/star/reflection/XIdlClassProvider.hpp>
  41 #include <com/sun/star/reflection/XIdlReflection.hpp>
  42 #include <com/sun/star/uno/XComponentContext.hpp>
  43 #include <com/sun/star/uno/DeploymentException.hpp>
  44 #include <com/sun/star/beans/XPropertySet.hpp>
  45
  46 using namespace com::sun::star;
  47 using namespace com::sun::star::uno;
  48 using namespace com::sun::star::lang;
  49 using namespace com::sun::star::reflection;
  50 using namespace rtl;
  51
  52 namespace cppu {
  53
  54 /*---------------------------------------------------------
  55 *       This helper class implements XIdlClass. Is used by
  56 *       createStdIdlClass()
  57 *---------------------------------------------------------*/
  58 class OStdIdlClass :
  59             public OWeakObject,
  60             public XIdlClass,
  61             public XIdlClassProvider
  62 {
  63 public:
  64     OStdIdlClass(
  65                     const Reference < XMultiServiceFactory > &rSMgr ,
  66                     const OUString & sImplementationName ,
  67                     const Reference < XIdlClass > & rSuperClass,
  68                     const Sequence < OUString > &seq
  69                 ) SAL_THROW( () );
  70
  71     // XInterface
  72     Any                                 SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType )
  73         throw(::com::sun::star::uno::RuntimeException);
  74
  75     void                                SAL_CALL acquire() throw()       { OWeakObject::acquire(); }
  76     void                                SAL_CALL release() throw()       { OWeakObject::release(); }
  77
  78     // XIdlClassProvider
  79     Sequence< Reference < XIdlClass > > SAL_CALL getIdlClasses(void)
  80         throw (RuntimeException);
  81
  82     // XIdlClass
  83     virtual Sequence< Reference< XIdlClass > > SAL_CALL getClasses(  ) throw(RuntimeException)
  84                                         { return Sequence < Reference < XIdlClass > > (); }
  85     virtual Reference< XIdlClass > SAL_CALL getClass( const ::rtl::OUString& ) throw(RuntimeException)
  86                                         { return Reference < XIdlClass > (); }
  87     virtual sal_Bool SAL_CALL equals( const Reference< XIdlClass >& Type ) throw(RuntimeException)
  88                                         { return getName() == Type->getName(); }
  89     virtual sal_Bool SAL_CALL isAssignableFrom( const Reference< XIdlClass >& xType ) throw(RuntimeException)
  90                                         { return equals( xType ); }
  91     virtual TypeClass SAL_CALL getTypeClass(  ) throw(RuntimeException)
  92                                         { return TypeClass_UNKNOWN; }
  93     virtual OUString SAL_CALL getName(  ) throw(RuntimeException)
  94                                         { return m_sImplementationName; }
  95     virtual Uik SAL_CALL getUik(  ) throw(RuntimeException)
  96                                         { return Uik(); }
  97     virtual Sequence< Reference< XIdlClass > > SAL_CALL getSuperclasses(  ) throw(RuntimeException)
  98                                         { return m_seqSuperClasses; }
  99     virtual Sequence< Reference< XIdlClass > > SAL_CALL getInterfaces(  ) throw(RuntimeException);
 100
 101     virtual Reference< XIdlClass > SAL_CALL getComponentType(  ) throw(RuntimeException)
 102                                         { return Reference < XIdlClass > (); }
 103     virtual Reference< XIdlField > SAL_CALL getField( const ::rtl::OUString& ) throw(RuntimeException)
 104                                         { return Reference < XIdlField > (); }
 105     virtual Sequence< Reference< XIdlField > > SAL_CALL getFields(  ) throw(RuntimeException)
 106                                         { return Sequence< Reference < XIdlField > > (); }
 107     virtual Reference< XIdlMethod > SAL_CALL getMethod( const ::rtl::OUString& ) throw(RuntimeException)
 108                                         { return Reference < XIdlMethod > (); }
 109     virtual Sequence< Reference< XIdlMethod > > SAL_CALL getMethods(  ) throw(RuntimeException)
 110                                         { return Sequence < Reference < XIdlMethod > > (); }
 111     virtual Reference< XIdlArray > SAL_CALL getArray(  ) throw(RuntimeException)
 112                                         { return Reference < XIdlArray > (); }
 113     virtual void SAL_CALL createObject( Any& ) throw(RuntimeException) {}
 114
 115 private:
 116     OUString                                                            m_sImplementationName;
 117     Sequence < OUString >                                       m_seqSupportedInterface;
 118     Sequence < Reference < XIdlClass > >        m_seqSuperClasses;
 119     Reference < XMultiServiceFactory >          m_rSMgr;
 120
 121     Reference< XIdlReflection > m_xCorefl;
 122     Reference< XIdlReflection > const & get_corefl() SAL_THROW( (RuntimeException) );
 123 };
 124
 125 Reference< XIdlReflection > const & OStdIdlClass::get_corefl()
 126     SAL_THROW( (RuntimeException) )
 127 {
 128     if (! m_xCorefl.is())
 129     {
 130         if( m_rSMgr.is() )
 131         {
 132             Reference< beans::XPropertySet > xProps( m_rSMgr, UNO_QUERY );
 133             OSL_ASSERT( xProps.is() );
 134             if (xProps.is())
 135             {
 136                 Reference< XComponentContext > xContext;
 137                 xProps->getPropertyValue(
 138                     OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ) >>= xContext;
 139                 OSL_ASSERT( xContext.is() );
 140                 if (xContext.is())
 141                 {
 142                     Reference < XIdlReflection > x;
 143                     xContext->getValueByName(
 144                         OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection") ) ) >>= x;
 145                     OSL_ENSURE( x.is(), "### CoreReflection singleton not accessible!?" );
 146
 147                     if (x.is())
 148                     {
 149                         ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() );
 150                         if (! m_xCorefl.is())
 151                         {
 152                             m_xCorefl = x;
 153                         }
 154                     }
 155                 }
 156             }
 157         }
 158         if (! m_xCorefl.is())
 159         {
 160             throw DeploymentException(
 161                 OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible") ),
 162                 Reference< XInterface >() );
 163         }
 164     }
 165     return m_xCorefl;
 166 }
 167
 168 OStdIdlClass::OStdIdlClass(
 169                     const Reference < XMultiServiceFactory > &rSMgr ,
 170                     const OUString & sImplementationName ,
 171                     const Reference < XIdlClass > & rSuperClass,
 172                     const Sequence < OUString > &seq
 173                           ) SAL_THROW( () ) :
 174                 m_sImplementationName( sImplementationName ) ,
 175                 m_seqSupportedInterface( seq ),
 176                 m_rSMgr( rSMgr )
 177 {
 178     if( rSuperClass.is() )
 179         m_seqSuperClasses = Sequence< Reference < XIdlClass > >( &rSuperClass, 1 );
 180
 181 }
 182
 183 Any SAL_CALL OStdIdlClass::queryInterface( const Type & rType )
 184      throw(::com::sun::star::uno::RuntimeException)
 185 {
 186     Any aRet( ::cppu::queryInterface(
 187         rType, static_cast< XIdlClass * >( this ), static_cast< XIdlClassProvider * >( this ) ) );
 188
 189     return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ));
 190 }
 191
 192
 193 Sequence< Reference< XIdlClass > > SAL_CALL OStdIdlClass::getInterfaces(  ) throw(RuntimeException)
 194 {
 195     int nMax = m_seqSupportedInterface.getLength();
 196
 197     Reference< XIdlReflection > const & rCoreRefl = get_corefl();
 198     if( rCoreRefl.is() )
 199     {
 200         Sequence< Reference< XIdlClass > > seqClasses( nMax );
 201
 202         for( int n = 0 ; n < nMax ; n++ )
 203         {
 204             seqClasses.getArray()[n] = rCoreRefl->forName( m_seqSupportedInterface.getArray()[n] );
 205         }
 206
 207         return seqClasses;
 208     }
 209     return Sequence< Reference< XIdlClass > > () ;
 210 }
 211
 212
 213 // XIdlClassProvider
 214 Sequence< Reference < XIdlClass > > SAL_CALL OStdIdlClass::getIdlClasses(void)
 215     throw (RuntimeException)
 216 {
 217     // weak reference to cache the standard class
 218     static WeakReference< XIdlClass >   weakRef;
 219
 220     // try to make weakref hard
 221     Reference < XIdlClass > r = weakRef;
 222
 223     if( ! r.is() ) {
 224         // xidlclass has not been initialized before or has been destroyed already.
 225         r = ::cppu::createStandardClass(
 226                                         m_rSMgr ,
 227                                         OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.cppuhelper.OStdIdlClass") ) ,
 228                                         Reference < XIdlClass > () ,
 229                                           SAL_STATIC_CAST( XIdlClassProvider * , this ) ,
 230                                           SAL_STATIC_CAST( XIdlClass * , this )
 231                                          );
 232
 233         // store reference for later use
 234         weakRef = r;
 235     }
 236
 237     return Sequence < Reference < XIdlClass > > ( &r , 1 );
 238 }
 239
 240
 241
 242
 243 // external constructor
 244 XIdlClass *  SAL_CALL createStandardClassWithSequence(
 245                     const Reference < XMultiServiceFactory > &rSMgr ,
 246                     const OUString & sImplementationName ,
 247                     const Reference < XIdlClass > & rSuperClass,
 248                     const Sequence < OUString > &seqInterfaceNames )
 249     SAL_THROW( () )
 250 {
 251     return SAL_STATIC_CAST(
 252                         XIdlClass * ,
 253                         new OStdIdlClass(
 254                                             rSMgr ,
 255                                             sImplementationName,
 256                                             rSuperClass,
 257                                             seqInterfaceNames
 258                                           )
 259                        );
 260 }
 261
 262 } //end namespace cppu