Line data    Source code

       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             : 
      10             : #include "sal/config.h"
      11             : 
      12             : #include <set>
      13             : #include <vector>
      14             : 
      15             : #include "osl/file.h"
      16             : #include "osl/file.hxx"
      17             : #include "osl/mutex.hxx"
      18             : #include "rtl/ref.hxx"
      19             : #include "rtl/ustring.hxx"
      20             : #include "unoidl/unoidl.hxx"
      21             : 
      22             : #include "legacyprovider.hxx"
      23             : #include "sourcefileprovider.hxx"
      24             : #include "sourcetreeprovider.hxx"
      25             : #include "unoidlprovider.hxx"
      26             : 
      27             : namespace unoidl {
      28             : 
      29             : namespace {
      30             : 
      31             : class AggregatingModule: public ModuleEntity {
      32             : public:
      33         636 :     AggregatingModule(
      34             :         std::vector< rtl::Reference< Provider > > const & providers,
      35             :         OUString const & name):
      36         636 :         providers_(providers), name_(name)
      37         636 :     {}
      38             : 
      39             : private:
      40        1272 :     virtual ~AggregatingModule() throw () {}
      41             : 
      42             :     virtual std::vector< OUString > getMemberNames() const SAL_OVERRIDE;
      43             : 
      44             :     virtual rtl::Reference< MapCursor > createCursor() const SAL_OVERRIDE;
      45             : 
      46             :     std::vector< rtl::Reference< Provider > > providers_;
      47             :     OUString name_;
      48             : };
      49             : 
      50           0 : std::vector< OUString > AggregatingModule::getMemberNames() const {
      51           0 :     std::set< OUString > names;
      52           0 :     for (std::vector< rtl::Reference< Provider > >::const_iterator i(
      53           0 :              providers_.begin());
      54           0 :          i != providers_.end(); ++i)
      55             :     {
      56           0 :         rtl::Reference< Entity > ent((*i)->findEntity(name_));
      57           0 :         if (ent.is() && ent->getSort() == Entity::SORT_MODULE) {
      58             :             std::vector< OUString > ns(
      59           0 :                 static_cast< ModuleEntity * >(ent.get())->getMemberNames());
      60           0 :             names.insert(ns.begin(), ns.end());
      61             :         }
      62           0 :     }
      63           0 :     return std::vector< OUString >(names.begin(), names.end());
      64             : }
      65             : 
      66             : class AggregatingCursor: public MapCursor {
      67             : public:
      68         509 :     AggregatingCursor(
      69             :         std::vector< rtl::Reference< Provider > > const & providers,
      70             :         OUString const & name):
      71         509 :         providers_(providers), name_(name), iterator_(providers_.begin())
      72         509 :     { findCursor(); }
      73             : 
      74             : private:
      75        1018 :     virtual ~AggregatingCursor() throw () {}
      76             : 
      77             :     virtual rtl::Reference< Entity > getNext(OUString * name) SAL_OVERRIDE;
      78             : 
      79             :     void findCursor();
      80             : 
      81             :     std::vector< rtl::Reference< Provider > > providers_;
      82             :     OUString name_;
      83             :     std::vector< rtl::Reference< Provider > >::iterator iterator_;
      84             :     rtl::Reference< MapCursor > cursor_;
      85             :     std::set< OUString > seen_;
      86             : };
      87             : 
      88       20515 : rtl::Reference< Entity > AggregatingCursor::getNext(OUString * name) {
      89       41816 :     while (cursor_.is()) {
      90       20792 :         OUString n;
      91       21578 :         rtl::Reference< Entity > ent(cursor_->getNext(&n));
      92       20792 :         if (ent.is()) {
      93       20219 :             if (seen_.insert(n).second) {
      94       20006 :                 if (name != 0) {
      95       20006 :                     *name = n;
      96             :                 }
      97       20006 :                 return ent->getSort() == Entity::SORT_MODULE
      98             :                     ? new AggregatingModule(
      99       21889 :                         providers_, (name_.isEmpty() ? name_ : name_ + ".") + n)
     100       40673 :                     : ent;
     101             :             }
     102             :         } else {
     103         573 :             cursor_.clear();
     104         573 :             findCursor();
     105             :         }
     106         786 :     }
     107         509 :     return rtl::Reference< Entity >();
     108             : }
     109             : 
     110        1082 : void AggregatingCursor::findCursor() {
     111        2307 :     for (; !cursor_.is() && iterator_ != providers_.end(); ++iterator_) {
     112        1225 :         if (name_.isEmpty()) {
     113          31 :             cursor_ = (*iterator_)->createRootCursor();
     114             :         } else {
     115        1194 :             rtl::Reference< Entity > ent((*iterator_)->findEntity(name_));
     116        1194 :             if (ent.is() && ent->getSort() == Entity::SORT_MODULE) {
     117        1626 :                 cursor_ = static_cast< ModuleEntity * >(ent.get())->
     118        1084 :                     createCursor();
     119        1194 :             }
     120             :         }
     121             :     }
     122        1082 : }
     123             : 
     124          36 : rtl::Reference< MapCursor > AggregatingModule::createCursor() const {
     125          36 :     return new AggregatingCursor(providers_, name_);
     126             : }
     127             : 
     128             : }
     129             : 
     130           0 : NoSuchFileException::~NoSuchFileException() throw () {}
     131             : 
     132           0 : FileFormatException::~FileFormatException() throw () {}
     133             : 
     134     1177735 : Entity::~Entity() throw () {}
     135             : 
     136        1767 : MapCursor::~MapCursor() throw () {}
     137             : 
     138        3806 : ModuleEntity::~ModuleEntity() throw () {}
     139             : 
     140     1173929 : PublishableEntity::~PublishableEntity() throw () {}
     141             : 
     142       32324 : EnumTypeEntity::~EnumTypeEntity() throw () {}
     143             : 
     144      103984 : PlainStructTypeEntity::~PlainStructTypeEntity() throw () {}
     145             : 
     146        3276 : PolymorphicStructTypeTemplateEntity::~PolymorphicStructTypeTemplateEntity()
     147        1638 :     throw ()
     148        3276 : {}
     149             : 
     150      152124 : ExceptionTypeEntity::~ExceptionTypeEntity() throw () {}
     151             : 
     152     1966750 : InterfaceTypeEntity::~InterfaceTypeEntity() throw () {}
     153             : 
     154        9566 : TypedefEntity::~TypedefEntity() throw () {}
     155             : 
     156       35200 : ConstantGroupEntity::~ConstantGroupEntity() throw () {}
     157             : 
     158       13812 : SingleInterfaceBasedServiceEntity::~SingleInterfaceBasedServiceEntity() throw ()
     159       13812 : {}
     160             : 
     161       28440 : AccumulationBasedServiceEntity::~AccumulationBasedServiceEntity() throw () {}
     162             : 
     163        2354 : InterfaceBasedSingletonEntity::~InterfaceBasedSingletonEntity() throw () {}
     164             : 
     165          28 : ServiceBasedSingletonEntity::~ServiceBasedSingletonEntity() throw () {}
     166             : 
     167        2518 : Provider::~Provider() throw () {}
     168             : 
     169        2651 : rtl::Reference< Provider > Manager::addProvider(OUString const & uri) {
     170        2651 :     rtl::Reference< Provider > p(loadProvider(uri));
     171             :     assert(p.is());
     172             :     {
     173        2281 :         osl::MutexGuard g(mutex_);
     174        2281 :         providers_.push_back(p);
     175             :     }
     176        2281 :     return p;
     177             : }
     178             : 
     179     1174932 : rtl::Reference< Entity > Manager::findEntity(rtl::OUString const & name) const {
     180             :     //TODO: caching? (here or in cppuhelper::TypeManager?)
     181     1174932 :     osl::MutexGuard g(mutex_);
     182     5634192 :     for (std::vector< rtl::Reference< Provider > >::const_iterator i(
     183     1174932 :              providers_.begin());
     184     4539416 :          i != providers_.end(); ++i)
     185             :     {
     186     2230576 :         rtl::Reference< Entity > ent((*i)->findEntity(name));
     187     2230576 :         if (ent.is()) {
     188     1135800 :             return ent;
     189             :         }
     190     1094776 :     }
     191       39132 :     return rtl::Reference< Entity >();
     192             : }
     193             : 
     194         473 : rtl::Reference< MapCursor > Manager::createCursor(rtl::OUString const & name)
     195             :     const
     196             : {
     197         473 :     return new AggregatingCursor(providers_, name);
     198             : }
     199             : 
     200        2580 : Manager::~Manager() throw () {}
     201             : 
     202        2651 : rtl::Reference< Provider > Manager::loadProvider(OUString const & uri) {
     203        2651 :     osl::DirectoryItem item;
     204        2651 :     if (osl::DirectoryItem::get(uri, item) == osl::FileBase::E_None) {
     205        2651 :         osl::FileStatus status(osl_FileStatus_Mask_Type);
     206        5302 :         if (item.getFileStatus(status) == osl::FileBase::E_None
     207        2651 :             && status.getFileType() == osl::FileStatus::Directory)
     208             :         {
     209         663 :             return new detail::SourceTreeProvider(*this, uri);
     210        1988 :         }
     211             :     }
     212        1988 :     if (uri.endsWith(".idl")) {
     213        1035 :         return new detail::SourceFileProvider(this, uri);
     214             :     }
     215             :     try {
     216        1323 :         return new detail::UnoidlProvider(uri);
     217           0 :     } catch (FileFormatException & e) {
     218             :         SAL_INFO(
     219             :             "unoidl",
     220             :             "FileFormatException \"" << e.getDetail() << "\", retrying <" << uri
     221             :                 << "> as legacy format");
     222           0 :         return new detail::LegacyProvider(*this, uri);
     223        2651 :     }
     224             : }
     225             : 
     226             : }
     227             : 
     228             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */