/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_cppuhelper.hxx" #include #include #include #include #include #include #include #include #include using namespace com::sun::star; using namespace com::sun::star::uno; using namespace com::sun::star::lang; using namespace com::sun::star::reflection; using namespace rtl; namespace cppu { /*--------------------------------------------------------- * This helper class implements XIdlClass. Is used by * createStdIdlClass() *---------------------------------------------------------*/ class OStdIdlClass : public OWeakObject, public XIdlClass, public XIdlClassProvider { public: OStdIdlClass( const Reference < XMultiServiceFactory > &rSMgr , const OUString & sImplementationName , const Reference < XIdlClass > & rSuperClass, const Sequence < OUString > &seq ) SAL_THROW( () ); // XInterface Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException); void SAL_CALL acquire() throw() { OWeakObject::acquire(); } void SAL_CALL release() throw() { OWeakObject::release(); } // XIdlClassProvider Sequence< Reference < XIdlClass > > SAL_CALL getIdlClasses(void) throw (RuntimeException); // XIdlClass virtual Sequence< Reference< XIdlClass > > SAL_CALL getClasses( ) throw(RuntimeException) { return Sequence < Reference < XIdlClass > > (); } virtual Reference< XIdlClass > SAL_CALL getClass( const ::rtl::OUString& ) throw(RuntimeException) { return Reference < XIdlClass > (); } virtual sal_Bool SAL_CALL equals( const Reference< XIdlClass >& Type ) throw(RuntimeException) { return getName() == Type->getName(); } virtual sal_Bool SAL_CALL isAssignableFrom( const Reference< XIdlClass >& xType ) throw(RuntimeException) { return equals( xType ); } virtual TypeClass SAL_CALL getTypeClass( ) throw(RuntimeException) { return TypeClass_UNKNOWN; } virtual OUString SAL_CALL getName( ) throw(RuntimeException) { return m_sImplementationName; } virtual Uik SAL_CALL getUik( ) throw(RuntimeException) { return Uik(); } virtual Sequence< Reference< XIdlClass > > SAL_CALL getSuperclasses( ) throw(RuntimeException) { return m_seqSuperClasses; } virtual Sequence< Reference< XIdlClass > > SAL_CALL getInterfaces( ) throw(RuntimeException); virtual Reference< XIdlClass > SAL_CALL getComponentType( ) throw(RuntimeException) { return Reference < XIdlClass > (); } virtual Reference< XIdlField > SAL_CALL getField( const ::rtl::OUString& ) throw(RuntimeException) { return Reference < XIdlField > (); } virtual Sequence< Reference< XIdlField > > SAL_CALL getFields( ) throw(RuntimeException) { return Sequence< Reference < XIdlField > > (); } virtual Reference< XIdlMethod > SAL_CALL getMethod( const ::rtl::OUString& ) throw(RuntimeException) { return Reference < XIdlMethod > (); } virtual Sequence< Reference< XIdlMethod > > SAL_CALL getMethods( ) throw(RuntimeException) { return Sequence < Reference < XIdlMethod > > (); } virtual Reference< XIdlArray > SAL_CALL getArray( ) throw(RuntimeException) { return Reference < XIdlArray > (); } virtual void SAL_CALL createObject( Any& ) throw(RuntimeException) {} private: OUString m_sImplementationName; Sequence < OUString > m_seqSupportedInterface; Sequence < Reference < XIdlClass > > m_seqSuperClasses; Reference < XMultiServiceFactory > m_rSMgr; Reference< XIdlReflection > m_xCorefl; Reference< XIdlReflection > const & get_corefl() SAL_THROW( (RuntimeException) ); }; Reference< XIdlReflection > const & OStdIdlClass::get_corefl() SAL_THROW( (RuntimeException) ) { if (! m_xCorefl.is()) { if( m_rSMgr.is() ) { Reference< beans::XPropertySet > xProps( m_rSMgr, UNO_QUERY ); OSL_ASSERT( xProps.is() ); if (xProps.is()) { Reference< XComponentContext > xContext; xProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ) >>= xContext; OSL_ASSERT( xContext.is() ); if (xContext.is()) { Reference < XIdlReflection > x; xContext->getValueByName( OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection") ) ) >>= x; OSL_ENSURE( x.is(), "### CoreReflection singleton not accessible!?" ); if (x.is()) { ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() ); if (! m_xCorefl.is()) { m_xCorefl = x; } } } } } if (! m_xCorefl.is()) { throw DeploymentException( OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible") ), Reference< XInterface >() ); } } return m_xCorefl; } OStdIdlClass::OStdIdlClass( const Reference < XMultiServiceFactory > &rSMgr , const OUString & sImplementationName , const Reference < XIdlClass > & rSuperClass, const Sequence < OUString > &seq ) SAL_THROW( () ) : m_sImplementationName( sImplementationName ) , m_seqSupportedInterface( seq ), m_rSMgr( rSMgr ) { if( rSuperClass.is() ) m_seqSuperClasses = Sequence< Reference < XIdlClass > >( &rSuperClass, 1 ); } Any SAL_CALL OStdIdlClass::queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException) { Any aRet( ::cppu::queryInterface( rType, static_cast< XIdlClass * >( this ), static_cast< XIdlClassProvider * >( this ) ) ); return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType )); } Sequence< Reference< XIdlClass > > SAL_CALL OStdIdlClass::getInterfaces( ) throw(RuntimeException) { int nMax = m_seqSupportedInterface.getLength(); Reference< XIdlReflection > const & rCoreRefl = get_corefl(); if( rCoreRefl.is() ) { Sequence< Reference< XIdlClass > > seqClasses( nMax ); for( int n = 0 ; n < nMax ; n++ ) { seqClasses.getArray()[n] = rCoreRefl->forName( m_seqSupportedInterface.getArray()[n] ); } return seqClasses; } return Sequence< Reference< XIdlClass > > () ; } // XIdlClassProvider Sequence< Reference < XIdlClass > > SAL_CALL OStdIdlClass::getIdlClasses(void) throw (RuntimeException) { // weak reference to cache the standard class static WeakReference< XIdlClass > weakRef; // try to make weakref hard Reference < XIdlClass > r = weakRef; if( ! r.is() ) { // xidlclass has not been initialized before or has been destroyed already. r = ::cppu::createStandardClass( m_rSMgr , OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.cppuhelper.OStdIdlClass") ) , Reference < XIdlClass > () , SAL_STATIC_CAST( XIdlClassProvider * , this ) , SAL_STATIC_CAST( XIdlClass * , this ) ); // store reference for later use weakRef = r; } return Sequence < Reference < XIdlClass > > ( &r , 1 ); } // external constructor XIdlClass * SAL_CALL createStandardClassWithSequence( const Reference < XMultiServiceFactory > &rSMgr , const OUString & sImplementationName , const Reference < XIdlClass > & rSuperClass, const Sequence < OUString > &seqInterfaceNames ) SAL_THROW( () ) { return SAL_STATIC_CAST( XIdlClass * , new OStdIdlClass( rSMgr , sImplementationName, rSuperClass, seqInterfaceNames ) ); } } //end namespace cppu