stoc/source/corereflection/crefl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <cppuhelper/queryinterface.hxx>
  21 #include <cppuhelper/supportsservice.hxx>
  22 #include <cppuhelper/typeprovider.hxx>
  23 #include <sal/log.hxx>
  24
  25 #include <com/sun/star/reflection/XConstantTypeDescription.hpp>
  26 #include <com/sun/star/reflection/XTypeDescription.hpp>
  27 #include <com/sun/star/uno/RuntimeException.hpp>
  28 #include <com/sun/star/uno/XComponentContext.hpp>
  29 #include <o3tl/any.hxx>
  30 #include <uno/lbnames.h>
  31 #include "base.hxx"
  32
  33 using namespace css;
  34 using namespace css::uno;
  35 using namespace css::lang;
  36 using namespace css::reflection;
  37 using namespace cppu;
  38 using namespace osl;
  39
  40 namespace stoc_corefl
  41 {
  42
  43 IdlReflectionServiceImpl::IdlReflectionServiceImpl(
  44     const Reference< XComponentContext > & xContext )
  45     : WeakComponentImplHelper( _aComponentMutex )
  46 {
  47     xContext->getValueByName(
  48         u"/singletons/com.sun.star.reflection.theTypeDescriptionManager"_ustr ) >>= _xTDMgr;
  49     OSL_ENSURE( _xTDMgr.is(), "### cannot get singleton \"TypeDescriptionManager\" from context!" );
  50 }
  51
  52 IdlReflectionServiceImpl::~IdlReflectionServiceImpl() {}
  53
  54 // XComponent
  55
  56 void IdlReflectionServiceImpl::disposing()
  57 {
  58     MutexGuard aGuard( _aComponentMutex );
  59     _aElements.clear();
  60 #ifdef TEST_LIST_CLASSES
  61     OSL_ENSURE( g_aClassNames.empty(), "### idl classes still alive!" );
  62     for (auto const& className : g_aClassNames)
  63     {
  64         OUString aName(className);
  65     }
  66 #endif
  67 }
  68
  69 // XServiceInfo
  70
  71 OUString IdlReflectionServiceImpl::getImplementationName()
  72 {
  73     return u"com.sun.star.comp.stoc.CoreReflection"_ustr;
  74 }
  75
  76 sal_Bool IdlReflectionServiceImpl::supportsService( const OUString & rServiceName )
  77 {
  78     return cppu::supportsService(this, rServiceName);
  79 }
  80
  81 Sequence< OUString > IdlReflectionServiceImpl::getSupportedServiceNames()
  82 {
  83     Sequence< OUString > seqNames { u"com.sun.star.reflection.CoreReflection"_ustr };
  84     return seqNames;
  85 }
  86
  87 // XIdlReflection
  88
  89 Reference< XIdlClass > IdlReflectionServiceImpl::getType( const Any & rObj )
  90 {
  91     return (rObj.hasValue() ? forType( rObj.getValueTypeRef() ) : Reference< XIdlClass >());
  92 }
  93
  94
  95 inline Reference< XIdlClass > IdlReflectionServiceImpl::constructClass(
  96     typelib_TypeDescription * pTypeDescr )
  97 {
  98     OSL_ENSURE( pTypeDescr->eTypeClass != typelib_TypeClass_TYPEDEF, "### unexpected typedef!" );
  99
 100     switch (pTypeDescr->eTypeClass)
 101     {
 102     case typelib_TypeClass_VOID:
 103     case typelib_TypeClass_CHAR:
 104     case typelib_TypeClass_BOOLEAN:
 105     case typelib_TypeClass_BYTE:
 106     case typelib_TypeClass_SHORT:
 107     case typelib_TypeClass_UNSIGNED_SHORT:
 108     case typelib_TypeClass_LONG:
 109     case typelib_TypeClass_UNSIGNED_LONG:
 110     case typelib_TypeClass_HYPER:
 111     case typelib_TypeClass_UNSIGNED_HYPER:
 112     case typelib_TypeClass_FLOAT:
 113     case typelib_TypeClass_DOUBLE:
 114     case typelib_TypeClass_STRING:
 115     case typelib_TypeClass_ANY:
 116         return new IdlClassImpl( this, pTypeDescr->pTypeName, pTypeDescr->eTypeClass, pTypeDescr );
 117
 118     case typelib_TypeClass_ENUM:
 119         return new EnumIdlClassImpl( this, pTypeDescr->pTypeName, pTypeDescr->eTypeClass, pTypeDescr );
 120
 121     case typelib_TypeClass_STRUCT:
 122     case typelib_TypeClass_EXCEPTION:
 123         return new CompoundIdlClassImpl( this, pTypeDescr->pTypeName, pTypeDescr->eTypeClass, pTypeDescr );
 124
 125     case typelib_TypeClass_SEQUENCE:
 126         return new ArrayIdlClassImpl( this, pTypeDescr->pTypeName, pTypeDescr->eTypeClass, pTypeDescr );
 127
 128     case typelib_TypeClass_INTERFACE:
 129         return new InterfaceIdlClassImpl( this, pTypeDescr->pTypeName, pTypeDescr->eTypeClass, pTypeDescr );
 130
 131     case typelib_TypeClass_TYPE:
 132         return new IdlClassImpl( this, pTypeDescr->pTypeName, pTypeDescr->eTypeClass, pTypeDescr );
 133
 134     default:
 135         SAL_INFO("stoc", "corereflection type unsupported: " << pTypeDescr->pTypeName);
 136         return Reference< XIdlClass >();
 137     }
 138 }
 139
 140 Reference< XIdlClass > IdlReflectionServiceImpl::forName( const OUString & rTypeName )
 141 {
 142     Reference< XIdlClass > xRet;
 143     Any aAny( _aElements.getValue( rTypeName ) );
 144
 145     if (aAny.hasValue())
 146     {
 147         aAny >>= xRet;
 148     }
 149     else
 150     {
 151         // try to get _type_ by name
 152         typelib_TypeDescription * pTD = nullptr;
 153         typelib_typedescription_getByName( &pTD, rTypeName.pData );
 154         if (pTD)
 155         {
 156             xRet = constructClass( pTD );
 157             if (xRet.is())
 158                 _aElements.setValue( rTypeName, Any( xRet ) ); // update
 159             typelib_typedescription_release( pTD );
 160         }
 161     }
 162
 163     return xRet;
 164 }
 165
 166 // XHierarchicalNameAccess
 167
 168 Any IdlReflectionServiceImpl::getByHierarchicalName( const OUString & rName )
 169 {
 170     Any aRet( _aElements.getValue( rName ) );
 171     if (! aRet.hasValue())
 172     {
 173         aRet = _xTDMgr->getByHierarchicalName( rName );
 174         if (aRet.getValueTypeClass() == TypeClass_INTERFACE)
 175         {
 176             // type retrieved from tdmgr
 177             OSL_ASSERT( (*o3tl::forceAccess<Reference<XInterface>>(aRet))->queryInterface(
 178                 cppu::UnoType<XTypeDescription>::get()).hasValue() );
 179
 180             css::uno::Reference< css::reflection::XConstantTypeDescription >
 181                 ctd;
 182             if (aRet >>= ctd)
 183             {
 184                 aRet = ctd->getConstantValue();
 185             }
 186             else
 187             {
 188                 // if you are interested in a type then CALL forName()!!!
 189                 // this way is NOT recommended for types, because this method looks for constants first
 190
 191                 // if td manager found some type, it will be in the cache (hopefully... we just got it)
 192                 // so the second retrieving via c typelib callback chain should succeed...
 193
 194                 // try to get _type_ by name
 195                 typelib_TypeDescription * pTD = nullptr;
 196                 typelib_typedescription_getByName( &pTD, rName.pData );
 197
 198                 aRet.clear(); // kick XTypeDescription interface
 199
 200                 if (pTD)
 201                 {
 202                     Reference< XIdlClass > xIdlClass( constructClass( pTD ) );
 203                     aRet.setValue( &xIdlClass, cppu::UnoType<XIdlClass>::get());
 204                     typelib_typedescription_release( pTD );
 205                 }
 206             }
 207         }
 208         // else is enum member(?)
 209
 210         // update
 211         if (!aRet.hasValue())
 212             throw container::NoSuchElementException( rName );
 213
 214         _aElements.setValue( rName, aRet );
 215     }
 216     return aRet;
 217 }
 218
 219 sal_Bool IdlReflectionServiceImpl::hasByHierarchicalName( const OUString & rName )
 220 {
 221     try
 222     {
 223         return getByHierarchicalName( rName ).hasValue();
 224     }
 225     catch (container::NoSuchElementException &)
 226     {
 227     }
 228     return false;
 229 }
 230
 231
 232 Reference< XIdlClass > IdlReflectionServiceImpl::forType( typelib_TypeDescription * pTypeDescr )
 233 {
 234     Reference< XIdlClass > xRet;
 235     OUString aName( pTypeDescr->pTypeName );
 236     Any aAny( _aElements.getValue( aName ) );
 237
 238     if (aAny.hasValue())
 239     {
 240         aAny >>= xRet;
 241     }
 242     else
 243     {
 244         xRet = constructClass( pTypeDescr );
 245         if (xRet.is())
 246             _aElements.setValue( aName, Any( xRet ) ); // update
 247     }
 248
 249     return xRet;
 250 }
 251
 252 Reference< XIdlClass > IdlReflectionServiceImpl::forType( typelib_TypeDescriptionReference * pRef )
 253 {
 254     typelib_TypeDescription * pTD = nullptr;
 255     TYPELIB_DANGER_GET( &pTD, pRef );
 256     if (pTD)
 257     {
 258         Reference< XIdlClass > xRet = forType( pTD );
 259         TYPELIB_DANGER_RELEASE( pTD );
 260         return xRet;
 261     }
 262     throw RuntimeException(
 263         u"IdlReflectionServiceImpl::forType() failed!"_ustr,
 264         getXWeak() );
 265 }
 266
 267
 268 const Mapping & IdlReflectionServiceImpl::getCpp2Uno()
 269 {
 270     if (! _aCpp2Uno.is())
 271     {
 272         MutexGuard aGuard( getMutexAccess() );
 273         if (! _aCpp2Uno.is())
 274         {
 275             _aCpp2Uno = Mapping( CPPU_CURRENT_LANGUAGE_BINDING_NAME, u"" UNO_LB_UNO ""_ustr );
 276             OSL_ENSURE( _aCpp2Uno.is(), "### cannot get c++ to uno mapping!" );
 277             if (! _aCpp2Uno.is())
 278             {
 279                 throw RuntimeException(
 280                     u"cannot get c++ to uno mapping!"_ustr,
 281                     getXWeak() );
 282             }
 283         }
 284     }
 285     return _aCpp2Uno;
 286 }
 287
 288 const Mapping & IdlReflectionServiceImpl::getUno2Cpp()
 289 {
 290     if (! _aUno2Cpp.is())
 291     {
 292         MutexGuard aGuard( getMutexAccess() );
 293         if (! _aUno2Cpp.is())
 294         {
 295             _aUno2Cpp = Mapping( u"" UNO_LB_UNO ""_ustr, CPPU_CURRENT_LANGUAGE_BINDING_NAME );
 296             OSL_ENSURE( _aUno2Cpp.is(), "### cannot get uno to c++ mapping!" );
 297             if (! _aUno2Cpp.is())
 298             {
 299                 throw RuntimeException(
 300                     u"cannot get uno to c++ mapping!"_ustr,
 301                     getXWeak() );
 302             }
 303         }
 304     }
 305     return _aUno2Cpp;
 306 }
 307
 308 uno_Interface * IdlReflectionServiceImpl::mapToUno(
 309     const Any & rObj, typelib_InterfaceTypeDescription * pTo )
 310 {
 311     Reference< XInterface > xObj;
 312     if (extract( rObj, pTo, xObj, this ))
 313         return static_cast<uno_Interface *>(getCpp2Uno().mapInterface( xObj.get(), pTo ));
 314
 315     throw RuntimeException(
 316         u"illegal object given!"_ustr,
 317         getXWeak() );
 318 }
 319
 320 }
 321
 322
 323 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 324 com_sun_star_comp_stoc_CoreReflection_get_implementation(
 325     css::uno::XComponentContext * context,
 326     css::uno::Sequence<css::uno::Any> const & arguments)
 327 {
 328     SAL_WARN_IF(
 329         arguments.hasElements(), "stoc", "unexpected singleton arguments");
 330     return cppu::acquire(new stoc_corefl::IdlReflectionServiceImpl(context));
 331 }
 332
 333 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */