binaryurp/source/bridgefactory.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 <sal/config.h>
  21
  22 #include <algorithm>
  23 #include <cassert>
  24 #include <exception>
  25
  26 #include <com/sun/star/bridge/BridgeExistsException.hpp>
  27 #include <com/sun/star/connection/XConnection.hpp>
  28 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  29 #include <com/sun/star/uno/Exception.hpp>
  30 #include <com/sun/star/uno/Reference.hxx>
  31 #include <com/sun/star/uno/RuntimeException.hpp>
  32 #include <com/sun/star/uno/XComponentContext.hpp>
  33 #include <com/sun/star/uno/XInterface.hpp>
  34 #include <cppuhelper/factory.hxx>
  35 #include <cppuhelper/implementationentry.hxx>
  36 #include <cppuhelper/supportsservice.hxx>
  37 #include <rtl/ref.hxx>
  38 #include <sal/log.hxx>
  39 #include <sal/types.h>
  40
  41 #include "bridge.hxx"
  42 #include "bridgefactory.hxx"
  43
  44 namespace binaryurp {
  45
  46 css::uno::Reference< css::uno::XInterface > BridgeFactory::static_create(
  47     css::uno::Reference< css::uno::XComponentContext > const & /*xContext*/)
  48 {
  49     return static_cast< cppu::OWeakObject * >(new BridgeFactory);
  50 }
  51
  52 OUString BridgeFactory::static_getImplementationName() {
  53     return OUString("com.sun.star.comp.bridge.BridgeFactory");
  54 }
  55
  56 css::uno::Sequence< OUString >
  57 BridgeFactory::static_getSupportedServiceNames() {
  58     return css::uno::Sequence<OUString>{ "com.sun.star.bridge.BridgeFactory" };
  59 }
  60
  61 void BridgeFactory::removeBridge(
  62     css::uno::Reference< css::bridge::XBridge > const & bridge)
  63 {
  64     assert(bridge.is());
  65     OUString n(bridge->getName());
  66     osl::MutexGuard g(m_aMutex);
  67     if (n.isEmpty())
  68     {
  69         unnamed_.erase(std::remove(unnamed_.begin(), unnamed_.end(), bridge), unnamed_.end());
  70     }
  71     else
  72     {
  73         BridgeMap::iterator i(named_.find(n));
  74         if (i != named_.end() && i->second == bridge)
  75             named_.erase(i);
  76     }
  77 }
  78
  79 BridgeFactory::BridgeFactory():
  80     BridgeFactoryBase(m_aMutex)
  81 {
  82 }
  83
  84 BridgeFactory::~BridgeFactory() {}
  85
  86 OUString BridgeFactory::getImplementationName()
  87 {
  88     return static_getImplementationName();
  89 }
  90
  91 sal_Bool BridgeFactory::supportsService(OUString const & ServiceName)
  92 {
  93     return cppu::supportsService(this, ServiceName);
  94 }
  95
  96 css::uno::Sequence< OUString > BridgeFactory::getSupportedServiceNames()
  97 {
  98     return static_getSupportedServiceNames();
  99 }
 100
 101 css::uno::Reference< css::bridge::XBridge > BridgeFactory::createBridge(
 102     OUString const & sName, OUString const & sProtocol,
 103     css::uno::Reference< css::connection::XConnection > const & aConnection,
 104     css::uno::Reference< css::bridge::XInstanceProvider > const &
 105         anInstanceProvider)
 106 {
 107     rtl::Reference< Bridge > b;
 108     {
 109         osl::MutexGuard g(m_aMutex);
 110         if (rBHelper.bDisposed) {
 111             throw css::lang::DisposedException(
 112                 "BridgeFactory disposed",
 113                 static_cast< cppu::OWeakObject * >(this));
 114         }
 115         if (named_.find(sName) != named_.end()) {
 116             throw css::bridge::BridgeExistsException(
 117                 sName, static_cast< cppu::OWeakObject * >(this));
 118         }
 119         if (sProtocol != "urp" || !aConnection.is()) {
 120             throw css::lang::IllegalArgumentException(
 121                 ("BridgeFactory::createBridge: sProtocol != urp ||"
 122                  " aConnection == null"),
 123                 static_cast< cppu::OWeakObject * >(this), -1);
 124         }
 125         b.set(new Bridge(this, sName, aConnection, anInstanceProvider));
 126         if (sName.isEmpty()) {
 127             unnamed_.emplace_back(b.get());
 128         } else {
 129             named_[sName] = b.get();
 130         }
 131     }
 132     b->start();
 133     return css::uno::Reference< css::bridge::XBridge >(b.get());
 134 }
 135
 136 css::uno::Reference< css::bridge::XBridge > BridgeFactory::getBridge(
 137     OUString const & sName)
 138 {
 139     osl::MutexGuard g(m_aMutex);
 140     BridgeMap::iterator i(named_.find(sName));
 141     return i == named_.end()
 142         ? css::uno::Reference< css::bridge::XBridge >() : i->second;
 143 }
 144
 145 css::uno::Sequence< css::uno::Reference< css::bridge::XBridge > >
 146 BridgeFactory::getExistingBridges() {
 147     osl::MutexGuard g(m_aMutex);
 148     if (unnamed_.size() > SAL_MAX_INT32) {
 149         throw css::uno::RuntimeException(
 150             "BridgeFactory::getExistingBridges: too many",
 151             static_cast< cppu::OWeakObject * >(this));
 152     }
 153     sal_Int32 n = static_cast< sal_Int32 >(unnamed_.size());
 154     if (named_.size() > static_cast< sal_uInt32 >(SAL_MAX_INT32 - n)) {
 155         throw css::uno::RuntimeException(
 156             "BridgeFactory::getExistingBridges: too many",
 157             static_cast< cppu::OWeakObject * >(this));
 158     }
 159     n = static_cast< sal_Int32 >(n + named_.size());
 160     css::uno::Sequence< css::uno::Reference< css::bridge::XBridge > > s(n);
 161     sal_Int32 i = 0;
 162     for (auto const& item : unnamed_)
 163         s[i++] = item;
 164
 165     for (auto const& item : named_)
 166         s[i++] = item.second;
 167
 168     return s;
 169 }
 170
 171 void BridgeFactory::disposing() {
 172     BridgeVector l1;
 173     BridgeMap l2;
 174     {
 175         osl::MutexGuard g(m_aMutex);
 176         l1.swap(unnamed_);
 177         l2.swap(named_);
 178     }
 179     for (auto const& item : l1)
 180     {
 181         try {
 182             css::uno::Reference<css::lang::XComponent>(
 183                 item, css::uno::UNO_QUERY_THROW)->dispose();
 184         } catch (css::uno::Exception & e) {
 185             SAL_WARN("binaryurp", "ignoring " << e);
 186         }
 187     }
 188     for (auto const& item : l2)
 189     {
 190         try {
 191             css::uno::Reference<css::lang::XComponent>(
 192                 item.second, css::uno::UNO_QUERY_THROW)->dispose();
 193         } catch (css::uno::Exception & e) {
 194             SAL_WARN("binaryurp", "ignoring " << e);
 195         }
 196     }
 197 }
 198
 199 }
 200
 201 namespace {
 202
 203 static cppu::ImplementationEntry const services[] = {
 204     { &binaryurp::BridgeFactory::static_create,
 205       &binaryurp::BridgeFactory::static_getImplementationName,
 206       &binaryurp::BridgeFactory::static_getSupportedServiceNames,
 207       &cppu::createOneInstanceComponentFactory, nullptr, 0 },
 208     { nullptr, nullptr, nullptr, nullptr, nullptr, 0 }
 209 };
 210
 211 }
 212
 213 extern "C" SAL_DLLPUBLIC_EXPORT void * binaryurp_component_getFactory(
 214     char const * pImplName, void * pServiceManager, void * pRegistryKey)
 215 {
 216     return cppu::component_getFactoryHelper(
 217         pImplName, pServiceManager, pRegistryKey, services);
 218 }
 219
 220 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */