| /************************************************************** | |
| * | |
| * 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 <osl/mutex.hxx> | |
| #include <cppuhelper/weakref.hxx> | |
| #include <cppuhelper/weak.hxx> | |
| #include <cppuhelper/stdidlclass.hxx> | |
| #include <com/sun/star/reflection/XIdlClassProvider.hpp> | |
| #include <com/sun/star/reflection/XIdlReflection.hpp> | |
| #include <com/sun/star/uno/XComponentContext.hpp> | |
| #include <com/sun/star/uno/DeploymentException.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| 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 ); | |
| void SAL_CALL acquire() throw() { OWeakObject::acquire(); } | |
| void SAL_CALL release() throw() { OWeakObject::release(); } | |
| // XIdlClassProvider | |
| Sequence< Reference < XIdlClass > > SAL_CALL getIdlClasses(void); | |
| // XIdlClass | |
| virtual Sequence< Reference< XIdlClass > > SAL_CALL getClasses( ) | |
| { return Sequence < Reference < XIdlClass > > (); } | |
| virtual Reference< XIdlClass > SAL_CALL getClass( const ::rtl::OUString& ) | |
| { return Reference < XIdlClass > (); } | |
| virtual sal_Bool SAL_CALL equals( const Reference< XIdlClass >& Type ) | |
| { return getName() == Type->getName(); } | |
| virtual sal_Bool SAL_CALL isAssignableFrom( const Reference< XIdlClass >& xType ) | |
| { return equals( xType ); } | |
| virtual TypeClass SAL_CALL getTypeClass( ) | |
| { return TypeClass_UNKNOWN; } | |
| virtual OUString SAL_CALL getName( ) | |
| { return m_sImplementationName; } | |
| virtual Uik SAL_CALL getUik( ) | |
| { return Uik(); } | |
| virtual Sequence< Reference< XIdlClass > > SAL_CALL getSuperclasses( ) | |
| { return m_seqSuperClasses; } | |
| virtual Sequence< Reference< XIdlClass > > SAL_CALL getInterfaces( ); | |
| virtual Reference< XIdlClass > SAL_CALL getComponentType( ) | |
| { return Reference < XIdlClass > (); } | |
| virtual Reference< XIdlField > SAL_CALL getField( const ::rtl::OUString& ) | |
| { return Reference < XIdlField > (); } | |
| virtual Sequence< Reference< XIdlField > > SAL_CALL getFields( ) | |
| { return Sequence< Reference < XIdlField > > (); } | |
| virtual Reference< XIdlMethod > SAL_CALL getMethod( const ::rtl::OUString& ) | |
| { return Reference < XIdlMethod > (); } | |
| virtual Sequence< Reference< XIdlMethod > > SAL_CALL getMethods( ) | |
| { return Sequence < Reference < XIdlMethod > > (); } | |
| virtual Reference< XIdlArray > SAL_CALL getArray( ) | |
| { return Reference < XIdlArray > (); } | |
| virtual void SAL_CALL createObject( Any& ) {} | |
| 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(); | |
| }; | |
| Reference< XIdlReflection > const & OStdIdlClass::get_corefl() | |
| { | |
| 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 ) | |
| { | |
| 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( ) | |
| { | |
| 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) | |
| { | |
| // 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 |