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