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