scripting/source/provider/ProviderCache.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 <comphelper/sequence.hxx>
  21 #include <tools/diagnose_ex.h>
  22 #include <sal/log.hxx>
  23
  24 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  25 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  26 #include <com/sun/star/lang/XServiceInfo.hpp>
  27 #include "ProviderCache.hxx"
  28
  29 using namespace com::sun::star;
  30 using namespace com::sun::star::uno;
  31 using namespace com::sun::star::script;
  32
  33 namespace func_provider
  34 {
  35
  36 ProviderCache::ProviderCache( const Reference< XComponentContext >& xContext, const Sequence< Any >& scriptContext ) : m_Sctx( scriptContext ), m_xContext( xContext )
  37 {
  38     // initialise m_hProviderDetailsCache with details of ScriptProviders
  39     // will use createContentEnumeration
  40
  41     m_xMgr = m_xContext->getServiceManager();
  42     ENSURE_OR_THROW( m_xMgr.is(), "ProviderCache::ProviderCache() failed to obtain ServiceManager" );
  43     populateCache();
  44 }
  45
  46
  47 ProviderCache::ProviderCache( const Reference< XComponentContext >& xContext, const Sequence< Any >& scriptContext, const Sequence< OUString >& denyList ) : m_sDenyList( denyList ), m_Sctx( scriptContext ), m_xContext( xContext )
  48
  49 {
  50     // initialise m_hProviderDetailsCache with details of ScriptProviders
  51     // will use createContentEnumeration
  52
  53     m_xMgr = m_xContext->getServiceManager();
  54     ENSURE_OR_THROW( m_xMgr.is(), "ProviderCache::ProviderCache() failed to obtain ServiceManager" );
  55     populateCache();
  56 }
  57
  58 ProviderCache::~ProviderCache()
  59 {
  60 }
  61
  62 Reference< provider::XScriptProvider >
  63 ProviderCache::getProvider( const OUString& providerName )
  64 {
  65     ::osl::Guard< osl::Mutex > aGuard( m_mutex );
  66     Reference< provider::XScriptProvider > provider;
  67     ProviderDetails_hash::iterator h_it = m_hProviderDetailsCache.find( providerName );
  68     if ( h_it != m_hProviderDetailsCache.end() )
  69     {
  70         if (  h_it->second.provider.is() )
  71         {
  72             provider = h_it->second.provider;
  73         }
  74         else
  75         {
  76             // need to create provider and insert into hash
  77             provider = createProvider( h_it->second );
  78         }
  79     }
  80     return provider;
  81 }
  82
  83 Sequence < Reference< provider::XScriptProvider > >
  84 ProviderCache::getAllProviders()
  85 {
  86     // need to create providers that haven't been created already
  87     // so check what providers exist and what ones don't
  88
  89     ::osl::Guard< osl::Mutex > aGuard( m_mutex );
  90     Sequence < Reference< provider::XScriptProvider > > providers (  m_hProviderDetailsCache.size() );
  91     // should assert if size !>  0
  92     if (  !m_hProviderDetailsCache.empty() )
  93     {
  94         sal_Int32 providerIndex = 0;
  95         for (auto& rDetail : m_hProviderDetailsCache)
  96         {
  97             Reference<provider::XScriptProvider> xScriptProvider = rDetail.second.provider;
  98             if ( xScriptProvider.is() )
  99             {
 100                 providers[ providerIndex++ ] = xScriptProvider;
 101             }
 102             else
 103             {
 104                 // create provider
 105                 try
 106                 {
 107                     xScriptProvider = createProvider(rDetail.second);
 108                     providers[ providerIndex++ ] = xScriptProvider;
 109                 }
 110                 catch ( const Exception& )
 111                 {
 112                     DBG_UNHANDLED_EXCEPTION("scripting");
 113                 }
 114             }
 115         }
 116
 117         if (providerIndex < providers.getLength())
 118         {
 119             providers.realloc( providerIndex );
 120         }
 121
 122     }
 123     else
 124     {
 125         SAL_WARN("scripting", "no available providers, something very wrong!!!");
 126     }
 127     return providers;
 128 }
 129
 130 void
 131 ProviderCache::populateCache()
 132 {
 133     // wrong name in services.rdb
 134     OUString serviceName;
 135     ::osl::Guard< osl::Mutex > aGuard( m_mutex );
 136     try
 137     {
 138         Reference< container::XContentEnumerationAccess > xEnumAccess( m_xMgr, UNO_QUERY_THROW );
 139         Reference< container::XEnumeration > xEnum = xEnumAccess->createContentEnumeration ( "com.sun.star.script.provider.LanguageScriptProvider" );
 140
 141         while ( xEnum->hasMoreElements() )
 142         {
 143
 144             Reference< lang::XSingleComponentFactory > factory( xEnum->nextElement(), UNO_QUERY_THROW );
 145             Reference< lang::XServiceInfo > xServiceInfo( factory, UNO_QUERY_THROW );
 146
 147             Sequence< OUString > serviceNames = xServiceInfo->getSupportedServiceNames();
 148
 149             if ( serviceNames.hasElements() )
 150             {
 151                 auto pName = std::find_if(serviceNames.begin(), serviceNames.end(),
 152                     [this](const OUString& rName) {
 153                         return rName.startsWith("com.sun.star.script.provider.ScriptProviderFor")
 154                             && !isInDenyList(rName);
 155                     });
 156                 if (pName != serviceNames.end())
 157                 {
 158                     serviceName = *pName;
 159                     ProviderDetails details;
 160                     details.factory = factory;
 161                     m_hProviderDetailsCache[ serviceName ] = details;
 162                 }
 163             }
 164         }
 165     }
 166     catch ( const Exception &e )
 167     {
 168         css::uno::Any anyEx = cppu::getCaughtException();
 169         throw css::lang::WrappedTargetRuntimeException(
 170                 "ProviderCache::populateCache: couldn't obtain XSingleComponentFactory for " + serviceName
 171                 + " " + e.Message,
 172                 nullptr, anyEx );
 173     }
 174 }
 175
 176 Reference< provider::XScriptProvider >
 177 ProviderCache::createProvider( ProviderDetails& details )
 178 {
 179     try
 180     {
 181         details.provider.set(
 182             details.factory->createInstanceWithArgumentsAndContext( m_Sctx, m_xContext ), UNO_QUERY_THROW );
 183     }
 184     catch ( const Exception& e )
 185     {
 186         css::uno::Any anyEx = cppu::getCaughtException();
 187         throw css::lang::WrappedTargetRuntimeException(
 188                 "ProviderCache::createProvider() Error creating provider from factory. " + e.Message,
 189                 nullptr, anyEx );
 190     }
 191
 192     return details.provider;
 193 }
 194
 195 bool
 196 ProviderCache::isInDenyList( const OUString& serviceName )
 197 {
 198     return comphelper::findValue(m_sDenyList, serviceName) != -1;
 199 }
 200 } //end namespace
 201
 202 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */