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