cppuhelper/source/typemanager.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 <cassert>
  13 #include <cstddef>
  14 #include <cstdlib>
  15 #include <cstring>
  16 #include <set>
  17 #include <stack>
  18 #include <vector>
  19
  20 #include <com/sun/star/container/ElementExistException.hpp>
  21 #include <com/sun/star/container/NoSuchElementException.hpp>
  22 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  23 #include <com/sun/star/reflection/InvalidTypeNameException.hpp>
  24 #include <com/sun/star/reflection/NoSuchTypeNameException.hpp>
  25 #include <com/sun/star/reflection/TypeDescriptionSearchDepth.hpp>
  26 #include <com/sun/star/reflection/XConstantTypeDescription.hpp>
  27 #include <com/sun/star/reflection/XConstantsTypeDescription.hpp>
  28 #include <com/sun/star/reflection/XEnumTypeDescription.hpp>
  29 #include <com/sun/star/reflection/XIndirectTypeDescription.hpp>
  30 #include <com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp>
  31 #include <com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp>
  32 #include <com/sun/star/reflection/XInterfaceTypeDescription2.hpp>
  33 #include <com/sun/star/reflection/XModuleTypeDescription.hpp>
  34 #include <com/sun/star/reflection/XPublished.hpp>
  35 #include <com/sun/star/reflection/XServiceTypeDescription2.hpp>
  36 #include <com/sun/star/reflection/XSingletonTypeDescription2.hpp>
  37 #include <com/sun/star/reflection/XStructTypeDescription.hpp>
  38 #include <com/sun/star/reflection/XTypeDescription.hpp>
  39 #include <com/sun/star/uno/Any.hxx>
  40 #include <com/sun/star/uno/DeploymentException.hpp>
  41 #include <com/sun/star/uno/Reference.hxx>
  42 #include <com/sun/star/uno/RuntimeException.hpp>
  43 #include <com/sun/star/uno/Sequence.hxx>
  44 #include <com/sun/star/uno/Type.hxx>
  45 #include <com/sun/star/uno/TypeClass.hpp>
  46 #include <cppu/unotype.hxx>
  47 #include <cppuhelper/implbase.hxx>
  48 #include <cppuhelper/supportsservice.hxx>
  49 #include <osl/file.hxx>
  50 #include <osl/mutex.hxx>
  51 #include <rtl/ref.hxx>
  52 #include <rtl/string.h>
  53 #include <rtl/ustring.hxx>
  54 #include <sal/log.hxx>
  55 #include <sal/macros.h>
  56 #include <sal/types.h>
  57
  58 using rtl::OUString;
  59
  60 #include <unoidl/unoidl.hxx>
  61
  62 #include "paths.hxx"
  63 #include "typemanager.hxx"
  64
  65 namespace {
  66
  67 rtl::OUString makePrefix(rtl::OUString const & name) {
  68     return name.isEmpty() ? name : name + ".";
  69 }
  70
  71 css::uno::Any resolveTypedefs(css::uno::Any const & type) {
  72     for (css::uno::Any t(type);;) {
  73         css::uno::Reference< css::reflection::XIndirectTypeDescription > ind(
  74             type, css::uno::UNO_QUERY);
  75         if (!ind.is() || ind->getTypeClass() != css::uno::TypeClass_TYPEDEF) {
  76             return t;
  77         }
  78         t <<= ind->getReferencedType();
  79     }
  80 }
  81
  82 class SimpleTypeDescription:
  83     public cppu::WeakImplHelper< css::reflection::XTypeDescription >
  84 {
  85 public:
  86     SimpleTypeDescription(
  87         css::uno::TypeClass typeClass, rtl::OUString const & name):
  88         typeClass_(typeClass), name_(name)
  89     {}
  90
  91 private:
  92     virtual ~SimpleTypeDescription() override {}
  93
  94     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
  95     { return typeClass_; }
  96
  97     virtual rtl::OUString SAL_CALL getName() override
  98     { return name_; }
  99
 100     css::uno::TypeClass typeClass_;
 101     rtl::OUString name_;
 102 };
 103
 104 class SequenceTypeDescription:
 105     public cppu::WeakImplHelper< css::reflection::XIndirectTypeDescription >
 106 {
 107 public:
 108     SequenceTypeDescription(
 109         rtl::Reference< cppuhelper::TypeManager > const & manager,
 110         rtl::OUString const & name, rtl::OUString const & componentType):
 111         manager_(manager), name_(name), componentType_(componentType)
 112     { assert(manager.is()); }
 113
 114 private:
 115     virtual ~SequenceTypeDescription() override {}
 116
 117     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 118     { return css::uno::TypeClass_SEQUENCE; }
 119
 120     virtual rtl::OUString SAL_CALL getName() override
 121     { return name_; }
 122
 123     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 124     getReferencedType() override
 125     { return manager_->resolve(componentType_); }
 126
 127     rtl::Reference< cppuhelper::TypeManager > manager_;
 128     rtl::OUString name_;
 129     rtl::OUString componentType_;
 130 };
 131
 132 class PublishableDescription:
 133     public cppu::WeakImplHelper< css::reflection::XPublished >
 134 {
 135 protected:
 136     explicit PublishableDescription(bool published): published_(published) {}
 137
 138     virtual ~PublishableDescription() override {}
 139
 140 private:
 141     virtual sal_Bool SAL_CALL isPublished() override
 142     { return published_; }
 143
 144     bool published_;
 145 };
 146
 147 class ModuleDescription:
 148     public cppu::WeakImplHelper< css::reflection::XModuleTypeDescription >
 149 {
 150 public:
 151     ModuleDescription(
 152         rtl::Reference< cppuhelper::TypeManager > const & manager,
 153         rtl::OUString const & name,
 154         rtl::Reference< unoidl::ModuleEntity > const & entity):
 155         manager_(manager), name_(name), entity_(entity)
 156     { assert(manager.is()); assert(entity.is()); }
 157
 158 private:
 159     virtual ~ModuleDescription() override {}
 160
 161     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 162     { return css::uno::TypeClass_MODULE; }
 163
 164     virtual rtl::OUString SAL_CALL getName() override
 165     { return name_; }
 166
 167     virtual
 168     css::uno::Sequence<
 169         css::uno::Reference< css::reflection::XTypeDescription > >
 170     SAL_CALL getMembers() override;
 171
 172     rtl::Reference< cppuhelper::TypeManager > manager_;
 173     rtl::OUString name_;
 174     rtl::Reference< unoidl::ModuleEntity > entity_;
 175 };
 176
 177 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 178 ModuleDescription::getMembers() {
 179     try {
 180         std::vector< rtl::OUString > names(entity_->getMemberNames());
 181         assert(names.size() <= SAL_MAX_INT32);
 182         sal_Int32 n = static_cast< sal_Int32 >(names.size());
 183         css::uno::Sequence<
 184             css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 185         for (sal_Int32 i = 0; i != n; ++i) {
 186             s[i] = manager_->resolve(makePrefix(name_) + names[i]);
 187         }
 188         return s;
 189     } catch (unoidl::FileFormatException & e) {
 190         throw css::uno::DeploymentException(
 191             e.getUri() + ": " + e.getDetail(),
 192             static_cast< cppu::OWeakObject * >(this));
 193     }
 194 }
 195
 196 typedef cppu::ImplInheritanceHelper<
 197     PublishableDescription, css::reflection::XEnumTypeDescription >
 198 EnumTypeDescription_Base;
 199
 200 class EnumTypeDescription: public EnumTypeDescription_Base {
 201 public:
 202     EnumTypeDescription(
 203         rtl::OUString const & name,
 204         rtl::Reference< unoidl::EnumTypeEntity > const & entity):
 205         EnumTypeDescription_Base(entity->isPublished()), name_(name),
 206         entity_(entity)
 207     { assert(entity.is()); }
 208
 209 private:
 210     virtual ~EnumTypeDescription() override {}
 211
 212     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 213     { return css::uno::TypeClass_ENUM; }
 214
 215     virtual rtl::OUString SAL_CALL getName() override
 216     { return name_; }
 217
 218     virtual sal_Int32 SAL_CALL getDefaultEnumValue() override
 219     { return entity_->getMembers()[0].value; }
 220
 221     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getEnumNames() override;
 222
 223     virtual css::uno::Sequence< sal_Int32 > SAL_CALL getEnumValues() override;
 224
 225     rtl::OUString name_;
 226     rtl::Reference< unoidl::EnumTypeEntity > entity_;
 227 };
 228
 229 css::uno::Sequence< rtl::OUString > EnumTypeDescription::getEnumNames()
 230 {
 231     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
 232     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
 233     css::uno::Sequence< rtl::OUString > s(n);
 234     for (sal_Int32 i = 0; i != n; ++i) {
 235         s[i] = entity_->getMembers()[i].name;
 236     }
 237     return s;
 238 }
 239
 240 css::uno::Sequence< sal_Int32 > EnumTypeDescription::getEnumValues()
 241 {
 242     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
 243     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
 244     css::uno::Sequence< sal_Int32 > s(n);
 245     for (sal_Int32 i = 0; i != n; ++i) {
 246         s[i] = entity_->getMembers()[i].value;
 247     }
 248     return s;
 249 }
 250
 251 typedef cppu::ImplInheritanceHelper<
 252     PublishableDescription, css::reflection::XStructTypeDescription >
 253 PlainStructTypeDescription_Base;
 254
 255 class PlainStructTypeDescription: public PlainStructTypeDescription_Base {
 256 public:
 257     PlainStructTypeDescription(
 258         rtl::Reference< cppuhelper::TypeManager > const & manager,
 259         rtl::OUString const & name,
 260         rtl::Reference< unoidl::PlainStructTypeEntity > const & entity):
 261         PlainStructTypeDescription_Base(entity->isPublished()),
 262         manager_(manager), name_(name), entity_(entity)
 263     { assert(manager.is()); assert(entity.is()); }
 264
 265 private:
 266     virtual ~PlainStructTypeDescription() override {}
 267
 268     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 269     { return css::uno::TypeClass_STRUCT; }
 270
 271     virtual rtl::OUString SAL_CALL getName() override
 272     { return name_; }
 273
 274     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 275     getBaseType() override {
 276         return entity_->getDirectBase().isEmpty()
 277             ? css::uno::Reference< css::reflection::XTypeDescription >()
 278             : manager_->resolve(entity_->getDirectBase());
 279     }
 280
 281     virtual
 282     css::uno::Sequence<
 283         css::uno::Reference< css::reflection::XTypeDescription > >
 284     SAL_CALL getMemberTypes() override;
 285
 286     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames() override;
 287
 288     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getTypeParameters() override
 289     { return css::uno::Sequence< rtl::OUString >(); }
 290
 291     virtual
 292     css::uno::Sequence<
 293         css::uno::Reference< css::reflection::XTypeDescription > >
 294     SAL_CALL getTypeArguments() override {
 295         return css::uno::Sequence<
 296             css::uno::Reference< css::reflection::XTypeDescription > >();
 297     }
 298
 299     rtl::Reference< cppuhelper::TypeManager > manager_;
 300     rtl::OUString name_;
 301     rtl::Reference< unoidl::PlainStructTypeEntity > entity_;
 302 };
 303
 304 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 305 PlainStructTypeDescription::getMemberTypes()
 306 {
 307     assert(entity_->getDirectMembers().size() <= SAL_MAX_INT32);
 308     sal_Int32 n = static_cast< sal_Int32 >(entity_->getDirectMembers().size());
 309     css::uno::Sequence<
 310         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 311     for (sal_Int32 i = 0; i != n; ++i) {
 312         s[i] = manager_->resolve(entity_->getDirectMembers()[i].type);
 313     }
 314     return s;
 315 }
 316
 317 css::uno::Sequence< rtl::OUString > PlainStructTypeDescription::getMemberNames()
 318 {
 319     assert(entity_->getDirectMembers().size() <= SAL_MAX_INT32);
 320     sal_Int32 n = static_cast< sal_Int32 >(entity_->getDirectMembers().size());
 321     css::uno::Sequence< rtl::OUString > s(n);
 322     for (sal_Int32 i = 0; i != n; ++i) {
 323         s[i] = entity_->getDirectMembers()[i].name;
 324     }
 325     return s;
 326 }
 327
 328 class ParameterizedMemberTypeDescription:
 329     public cppu::WeakImplHelper< css::reflection::XTypeDescription >
 330 {
 331 public:
 332     explicit ParameterizedMemberTypeDescription(
 333         rtl::OUString const & typeParameterName):
 334         typeParameterName_(typeParameterName)
 335     {}
 336
 337 private:
 338     virtual ~ParameterizedMemberTypeDescription() override {}
 339
 340     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 341     { return css::uno::TypeClass_UNKNOWN; }
 342
 343     virtual rtl::OUString SAL_CALL getName() override
 344     { return typeParameterName_; }
 345
 346     rtl::OUString typeParameterName_;
 347 };
 348
 349 typedef cppu::ImplInheritanceHelper<
 350     PublishableDescription, css::reflection::XStructTypeDescription >
 351 PolymorphicStructTypeTemplateDescription_Base;
 352
 353 class PolymorphicStructTypeTemplateDescription:
 354     public PolymorphicStructTypeTemplateDescription_Base
 355 {
 356 public:
 357     PolymorphicStructTypeTemplateDescription(
 358         rtl::Reference< cppuhelper::TypeManager > const & manager,
 359         rtl::OUString const & name,
 360         rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
 361             entity):
 362         PolymorphicStructTypeTemplateDescription_Base(entity->isPublished()),
 363         manager_(manager), name_(name), entity_(entity)
 364     { assert(manager.is()); assert(entity.is()); }
 365
 366 private:
 367     virtual ~PolymorphicStructTypeTemplateDescription() override {}
 368
 369     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 370     { return css::uno::TypeClass_STRUCT; }
 371
 372     virtual rtl::OUString SAL_CALL getName() override
 373     { return name_; }
 374
 375     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 376     getBaseType() override
 377     { return css::uno::Reference< css::reflection::XTypeDescription >(); }
 378
 379     virtual
 380     css::uno::Sequence<
 381         css::uno::Reference< css::reflection::XTypeDescription > >
 382     SAL_CALL getMemberTypes() override;
 383
 384     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames() override;
 385
 386     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getTypeParameters() override;
 387
 388     virtual
 389     css::uno::Sequence<
 390         css::uno::Reference< css::reflection::XTypeDescription > >
 391     SAL_CALL getTypeArguments() override {
 392         return css::uno::Sequence<
 393             css::uno::Reference< css::reflection::XTypeDescription > >();
 394     }
 395
 396     rtl::Reference< cppuhelper::TypeManager > manager_;
 397     rtl::OUString name_;
 398     rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
 399 };
 400
 401 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 402 PolymorphicStructTypeTemplateDescription::getMemberTypes()
 403 {
 404     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
 405     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
 406     css::uno::Sequence<
 407         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 408     for (sal_Int32 i = 0; i != n; ++i) {
 409         s[i] = entity_->getMembers()[i].parameterized
 410             ? new ParameterizedMemberTypeDescription(
 411                 entity_->getMembers()[i].type)
 412             : manager_->resolve(entity_->getMembers()[i].type);
 413     }
 414     return s;
 415 }
 416
 417 css::uno::Sequence< rtl::OUString >
 418 PolymorphicStructTypeTemplateDescription::getMemberNames()
 419 {
 420     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
 421     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
 422     css::uno::Sequence< rtl::OUString > s(n);
 423     for (sal_Int32 i = 0; i != n; ++i) {
 424         s[i] = entity_->getMembers()[i].name;
 425     }
 426     return s;
 427 }
 428
 429 css::uno::Sequence< rtl::OUString >
 430 PolymorphicStructTypeTemplateDescription::getTypeParameters()
 431 {
 432     assert(entity_->getTypeParameters().size() <= SAL_MAX_INT32);
 433     sal_Int32 n = static_cast< sal_Int32 >(entity_->getTypeParameters().size());
 434     css::uno::Sequence< rtl::OUString > s(n);
 435     for (sal_Int32 i = 0; i != n; ++i) {
 436         s[i] = entity_->getTypeParameters()[i];
 437     }
 438     return s;
 439 }
 440
 441 class InstantiatedPolymorphicStructTypeDescription:
 442     public cppu::WeakImplHelper< css::reflection::XStructTypeDescription >
 443 {
 444 public:
 445     InstantiatedPolymorphicStructTypeDescription(
 446         rtl::Reference< cppuhelper::TypeManager > const & manager,
 447         rtl::OUString const & name,
 448         rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
 449             entity,
 450         std::vector< rtl::OUString > const & arguments):
 451         manager_(manager), name_(name), entity_(entity), arguments_(arguments)
 452     {
 453         assert(manager.is());
 454         assert(entity.is());
 455         assert(arguments.size() == entity->getTypeParameters().size());
 456     }
 457
 458 private:
 459     virtual ~InstantiatedPolymorphicStructTypeDescription() override {}
 460
 461     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 462     { return css::uno::TypeClass_STRUCT; }
 463
 464     virtual rtl::OUString SAL_CALL getName() override
 465     { return name_; }
 466
 467     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 468     getBaseType() override
 469     { return css::uno::Reference< css::reflection::XTypeDescription >(); }
 470
 471     virtual
 472     css::uno::Sequence<
 473         css::uno::Reference< css::reflection::XTypeDescription > >
 474     SAL_CALL getMemberTypes() override;
 475
 476     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames() override;
 477
 478     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getTypeParameters() override
 479     { return css::uno::Sequence< rtl::OUString >(); }
 480
 481     virtual
 482     css::uno::Sequence<
 483         css::uno::Reference< css::reflection::XTypeDescription > >
 484     SAL_CALL getTypeArguments() override;
 485
 486     rtl::Reference< cppuhelper::TypeManager > manager_;
 487     rtl::OUString name_;
 488     rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
 489     std::vector< rtl::OUString > arguments_;
 490 };
 491
 492 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 493 InstantiatedPolymorphicStructTypeDescription::getMemberTypes()
 494 {
 495     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
 496     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
 497     css::uno::Sequence<
 498         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 499     for (sal_Int32 i = 0; i != n; ++i) {
 500         rtl::OUString type(entity_->getMembers()[i].type);
 501         if (entity_->getMembers()[i].parameterized) {
 502             for (std::vector< rtl::OUString >::const_iterator j(
 503                      entity_->getTypeParameters().begin());
 504                  j != entity_->getTypeParameters().end(); ++j)
 505             {
 506                 if (*j == type) {
 507                     type = arguments_[j - entity_->getTypeParameters().begin()];
 508                     goto found;
 509                 }
 510             }
 511             assert(false); // this cannot happen                         //TODO!
 512         found:;
 513         }
 514         s[i] = manager_->resolve(type);
 515     }
 516     return s;
 517 }
 518
 519 css::uno::Sequence< rtl::OUString >
 520 InstantiatedPolymorphicStructTypeDescription::getMemberNames()
 521 {
 522     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
 523     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
 524     css::uno::Sequence< rtl::OUString > s(n);
 525     for (sal_Int32 i = 0; i != n; ++i) {
 526         s[i] = entity_->getMembers()[i].name;
 527     }
 528     return s;
 529 }
 530 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 531 InstantiatedPolymorphicStructTypeDescription::getTypeArguments()
 532 {
 533     assert(arguments_.size() <= SAL_MAX_INT32);
 534     sal_Int32 n = static_cast< sal_Int32 >(arguments_.size());
 535     css::uno::Sequence<
 536         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 537     for (sal_Int32 i = 0; i != n; ++i) {
 538         s[i] = manager_->resolve(arguments_[i]);
 539     }
 540     return s;
 541 }
 542
 543 typedef cppu::ImplInheritanceHelper<
 544     PublishableDescription, css::reflection::XCompoundTypeDescription >
 545 ExceptionTypeDescription_Base;
 546
 547 class ExceptionTypeDescription: public ExceptionTypeDescription_Base {
 548 public:
 549     ExceptionTypeDescription(
 550         rtl::Reference< cppuhelper::TypeManager > const & manager,
 551         rtl::OUString const & name,
 552         rtl::Reference< unoidl::ExceptionTypeEntity > const & entity):
 553         ExceptionTypeDescription_Base(entity->isPublished()), manager_(manager),
 554         name_(name), entity_(entity)
 555     { assert(manager.is()); assert(entity.is()); }
 556
 557 private:
 558     virtual ~ExceptionTypeDescription() override {}
 559
 560     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 561     { return css::uno::TypeClass_EXCEPTION; }
 562
 563     virtual rtl::OUString SAL_CALL getName() override
 564     { return name_; }
 565
 566     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 567     getBaseType() override {
 568         return entity_->getDirectBase().isEmpty()
 569             ? css::uno::Reference< css::reflection::XTypeDescription >()
 570             : manager_->resolve(entity_->getDirectBase());
 571     }
 572
 573     virtual
 574     css::uno::Sequence<
 575         css::uno::Reference< css::reflection::XTypeDescription > >
 576     SAL_CALL getMemberTypes() override;
 577
 578     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames() override;
 579
 580     rtl::Reference< cppuhelper::TypeManager > manager_;
 581     rtl::OUString name_;
 582     rtl::Reference< unoidl::ExceptionTypeEntity > entity_;
 583 };
 584
 585 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 586 ExceptionTypeDescription::getMemberTypes() {
 587     assert(entity_->getDirectMembers().size() <= SAL_MAX_INT32);
 588     sal_Int32 n = static_cast< sal_Int32 >(entity_->getDirectMembers().size());
 589     css::uno::Sequence<
 590         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 591     for (sal_Int32 i = 0; i != n; ++i) {
 592         s[i] = manager_->resolve(entity_->getDirectMembers()[i].type);
 593     }
 594     return s;
 595 }
 596
 597 css::uno::Sequence< rtl::OUString > ExceptionTypeDescription::getMemberNames()
 598 {
 599     assert(entity_->getDirectMembers().size() <= SAL_MAX_INT32);
 600     sal_Int32 n = static_cast< sal_Int32 >(entity_->getDirectMembers().size());
 601     css::uno::Sequence< rtl::OUString > s(n);
 602     for (sal_Int32 i = 0; i != n; ++i) {
 603         s[i] = entity_->getDirectMembers()[i].name;
 604     }
 605     return s;
 606 }
 607
 608 class AttributeDescription:
 609     public cppu::WeakImplHelper<
 610         css::reflection::XInterfaceAttributeTypeDescription2 >
 611 {
 612 public:
 613     AttributeDescription(
 614         rtl::Reference< cppuhelper::TypeManager > const & manager,
 615         rtl::OUString const & name,
 616         unoidl::InterfaceTypeEntity::Attribute const & attribute,
 617         sal_Int32 position):
 618         manager_(manager), name_(name), attribute_(attribute),
 619         position_(position)
 620     { assert(manager.is()); }
 621
 622 private:
 623     virtual ~AttributeDescription() override {}
 624
 625     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 626     { return css::uno::TypeClass_INTERFACE_ATTRIBUTE; }
 627
 628     virtual rtl::OUString SAL_CALL getName() override
 629     { return name_; }
 630
 631     virtual rtl::OUString SAL_CALL getMemberName() override
 632     { return attribute_.name; }
 633
 634     virtual sal_Int32 SAL_CALL getPosition() override
 635     { return position_; }
 636
 637     virtual sal_Bool SAL_CALL isReadOnly() override
 638     { return attribute_.readOnly; }
 639
 640     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 641     getType() override
 642     { return manager_->resolve(attribute_.type); }
 643
 644     virtual sal_Bool SAL_CALL isBound() override
 645     { return attribute_.bound; }
 646
 647     virtual
 648     css::uno::Sequence<
 649         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
 650     SAL_CALL getGetExceptions() override;
 651
 652     virtual
 653     css::uno::Sequence<
 654         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
 655     SAL_CALL getSetExceptions() override;
 656
 657     rtl::Reference< cppuhelper::TypeManager > manager_;
 658     rtl::OUString name_;
 659     unoidl::InterfaceTypeEntity::Attribute attribute_;
 660     sal_Int32 position_;
 661 };
 662
 663 css::uno::Sequence<
 664     css::uno::Reference< css::reflection::XCompoundTypeDescription > >
 665 AttributeDescription::getGetExceptions() {
 666     assert(attribute_.getExceptions.size() <= SAL_MAX_INT32);
 667     sal_Int32 n = static_cast< sal_Int32 >(attribute_.getExceptions.size());
 668     css::uno::Sequence<
 669         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
 670     for (sal_Int32 i = 0; i != n; ++i) {
 671         s[i].set(
 672             manager_->resolve(attribute_.getExceptions[i]),
 673             css::uno::UNO_QUERY_THROW);
 674     }
 675     return s;
 676 }
 677
 678 css::uno::Sequence<
 679     css::uno::Reference< css::reflection::XCompoundTypeDescription > >
 680 AttributeDescription::getSetExceptions() {
 681     assert(attribute_.setExceptions.size() <= SAL_MAX_INT32);
 682     sal_Int32 n = static_cast< sal_Int32 >(attribute_.setExceptions.size());
 683     css::uno::Sequence<
 684         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
 685     for (sal_Int32 i = 0; i != n; ++i) {
 686         s[i].set(
 687             manager_->resolve(attribute_.setExceptions[i]),
 688             css::uno::UNO_QUERY_THROW);
 689     }
 690     return s;
 691 }
 692
 693 class MethodParameter:
 694     public cppu::WeakImplHelper< css::reflection::XMethodParameter >
 695 {
 696 public:
 697     MethodParameter(
 698         rtl::Reference< cppuhelper::TypeManager > const & manager,
 699         unoidl::InterfaceTypeEntity::Method::Parameter const & parameter,
 700         sal_Int32 position):
 701         manager_(manager), parameter_(parameter), position_(position)
 702     { assert(manager.is()); }
 703
 704 private:
 705     virtual ~MethodParameter() override {}
 706
 707     virtual rtl::OUString SAL_CALL getName() override
 708     { return parameter_.name; }
 709
 710     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 711     getType() override
 712     { return manager_->resolve(parameter_.type); }
 713
 714     virtual sal_Bool SAL_CALL isIn() override {
 715         return
 716             (parameter_.direction
 717              == unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_IN)
 718             || (parameter_.direction
 719                 == unoidl::InterfaceTypeEntity::Method::Parameter::
 720                     DIRECTION_IN_OUT);
 721     }
 722
 723     virtual sal_Bool SAL_CALL isOut() override {
 724         return
 725             (parameter_.direction
 726              == unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_OUT)
 727             || (parameter_.direction
 728                 == unoidl::InterfaceTypeEntity::Method::Parameter::
 729                     DIRECTION_IN_OUT);
 730     }
 731
 732     virtual sal_Int32 SAL_CALL getPosition() override
 733     { return position_; }
 734
 735     rtl::Reference< cppuhelper::TypeManager > manager_;
 736     unoidl::InterfaceTypeEntity::Method::Parameter parameter_;
 737     sal_Int32 position_;
 738 };
 739
 740 class MethodDescription:
 741     public cppu::WeakImplHelper<
 742         css::reflection::XInterfaceMethodTypeDescription >
 743 {
 744 public:
 745     MethodDescription(
 746         rtl::Reference< cppuhelper::TypeManager > const & manager,
 747         rtl::OUString const & name,
 748         unoidl::InterfaceTypeEntity::Method const & method, sal_Int32 position):
 749         manager_(manager), name_(name), method_(method), position_(position)
 750     { assert(manager.is()); }
 751
 752 private:
 753     virtual ~MethodDescription() override {}
 754
 755     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 756     { return css::uno::TypeClass_INTERFACE_METHOD; }
 757
 758     virtual rtl::OUString SAL_CALL getName() override
 759     { return name_; }
 760
 761     virtual rtl::OUString SAL_CALL getMemberName() override
 762     { return method_.name; }
 763
 764     virtual sal_Int32 SAL_CALL getPosition() override
 765     { return position_; }
 766
 767     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 768     getReturnType() override
 769     { return manager_->resolve(method_.returnType); }
 770
 771     virtual sal_Bool SAL_CALL isOneway() override
 772     { return false; }
 773
 774     virtual
 775     css::uno::Sequence<
 776         css::uno::Reference< css::reflection::XMethodParameter > >
 777     SAL_CALL getParameters() override;
 778
 779     virtual
 780     css::uno::Sequence<
 781         css::uno::Reference< css::reflection::XTypeDescription > >
 782     SAL_CALL getExceptions() override;
 783
 784     rtl::Reference< cppuhelper::TypeManager > manager_;
 785     rtl::OUString name_;
 786     unoidl::InterfaceTypeEntity::Method method_;
 787     sal_Int32 position_;
 788 };
 789
 790 css::uno::Sequence< css::uno::Reference< css::reflection::XMethodParameter > >
 791 MethodDescription::getParameters() {
 792     assert(method_.parameters.size() <= SAL_MAX_INT32);
 793     sal_Int32 n = static_cast< sal_Int32 >(method_.parameters.size());
 794     css::uno::Sequence<
 795         css::uno::Reference< css::reflection::XMethodParameter > > s(n);
 796     for (sal_Int32 i = 0; i != n; ++i) {
 797         s[i] = new MethodParameter(manager_, method_.parameters[i], i);
 798     }
 799     return s;
 800 }
 801
 802 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 803 MethodDescription::getExceptions() {
 804     assert(method_.exceptions.size() <= SAL_MAX_INT32);
 805     sal_Int32 n = static_cast< sal_Int32 >(method_.exceptions.size());
 806     css::uno::Sequence<
 807         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 808     for (sal_Int32 i = 0; i != n; ++i) {
 809         s[i] = manager_->resolve(method_.exceptions[i]);
 810     }
 811     return s;
 812 }
 813
 814 class BaseOffset {
 815 public:
 816     explicit BaseOffset(
 817         css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
 818             const & description);
 819
 820     BaseOffset(const BaseOffset&) = delete;
 821     const BaseOffset& operator=(const BaseOffset&) = delete;
 822
 823     sal_Int32 get() const { return offset_; }
 824
 825 private:
 826     void calculateBases(
 827         css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
 828             const & description);
 829
 830     void calculate(
 831         css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
 832             const & description);
 833
 834     std::set< rtl::OUString > set_;
 835     sal_Int32 offset_;
 836 };
 837
 838 BaseOffset::BaseOffset(
 839     css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
 840         description):
 841     offset_(0)
 842 {
 843     calculateBases(description);
 844 }
 845
 846 void BaseOffset::calculateBases(
 847     css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
 848         description)
 849 {
 850     css::uno::Sequence<
 851         css::uno::Reference < css::reflection::XTypeDescription > > bases(
 852             description->getBaseTypes());
 853     for (sal_Int32 i = 0; i != bases.getLength(); ++i) {
 854         calculate(
 855             css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
 856                 resolveTypedefs(css::uno::makeAny(bases[i])),
 857                 css::uno::UNO_QUERY_THROW));
 858     }
 859 }
 860
 861 void BaseOffset::calculate(
 862     css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
 863         description)
 864 {
 865     if (set_.insert(description->getName()).second) {
 866         calculateBases(description);
 867         offset_ += description->getMembers().getLength();
 868     }
 869 }
 870
 871 typedef cppu::ImplInheritanceHelper<
 872     PublishableDescription, css::reflection::XInterfaceTypeDescription2 >
 873 InterfaceTypeDescription_Base;
 874
 875 class InterfaceTypeDescription: public InterfaceTypeDescription_Base {
 876 public:
 877     InterfaceTypeDescription(
 878         rtl::Reference< cppuhelper::TypeManager > const & manager,
 879         rtl::OUString const & name,
 880         rtl::Reference< unoidl::InterfaceTypeEntity > const & entity):
 881         InterfaceTypeDescription_Base(entity->isPublished()), manager_(manager),
 882         name_(name), entity_(entity)
 883     { assert(manager.is()); assert(entity.is()); }
 884
 885 private:
 886     virtual ~InterfaceTypeDescription() override {}
 887
 888     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 889     { return css::uno::TypeClass_INTERFACE; }
 890
 891     virtual rtl::OUString SAL_CALL getName() override
 892     { return name_; }
 893
 894     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
 895     getBaseType() override {
 896         return entity_->getDirectMandatoryBases().empty()
 897             ? css::uno::Reference< css::reflection::XTypeDescription >()
 898             : manager_->resolve(entity_->getDirectMandatoryBases()[0].name);
 899     }
 900
 901     virtual css::uno::Uik SAL_CALL getUik() override
 902     { return css::uno::Uik(); }
 903
 904     virtual
 905     css::uno::Sequence<
 906         css::uno::Reference<
 907              css::reflection::XInterfaceMemberTypeDescription > >
 908     SAL_CALL getMembers() override;
 909
 910     virtual
 911     css::uno::Sequence<
 912         css::uno::Reference< css::reflection::XTypeDescription > >
 913     SAL_CALL getBaseTypes() override;
 914
 915     virtual
 916     css::uno::Sequence<
 917         css::uno::Reference< css::reflection::XTypeDescription > >
 918     SAL_CALL getOptionalBaseTypes() override;
 919
 920     rtl::Reference< cppuhelper::TypeManager > manager_;
 921     rtl::OUString name_;
 922     rtl::Reference< unoidl::InterfaceTypeEntity > entity_;
 923 };
 924
 925 css::uno::Sequence<
 926     css::uno::Reference< css::reflection::XInterfaceMemberTypeDescription > >
 927 InterfaceTypeDescription::getMembers() {
 928     assert(
 929         entity_->getDirectAttributes().size() <= SAL_MAX_INT32
 930         && (entity_->getDirectMethods().size()
 931             <= SAL_MAX_INT32 - entity_->getDirectAttributes().size()));
 932     sal_Int32 n1 = static_cast< sal_Int32 >(
 933         entity_->getDirectAttributes().size());
 934     sal_Int32 n2 = static_cast< sal_Int32 >(entity_->getDirectMethods().size());
 935     css::uno::Sequence<
 936         css::uno::Reference<
 937             css::reflection::XInterfaceMemberTypeDescription > > s(n1 + n2);
 938     sal_Int32 off = BaseOffset(this).get();
 939     for (sal_Int32 i = 0; i != n1; ++i) {
 940         s[i] = new AttributeDescription(
 941             manager_, name_ + "::" + entity_->getDirectAttributes()[i].name,
 942             entity_->getDirectAttributes()[i], off + i);
 943     }
 944     for (sal_Int32 i = 0; i != n2; ++i) {
 945         s[n1 + i] = new MethodDescription(
 946             manager_, name_ + "::" + entity_->getDirectMethods()[i].name,
 947             entity_->getDirectMethods()[i], off + n1 + i);
 948     }
 949     return s;
 950 }
 951
 952 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 953 InterfaceTypeDescription::getBaseTypes() {
 954     assert(entity_->getDirectMandatoryBases().size() <= SAL_MAX_INT32);
 955     sal_Int32 n = static_cast< sal_Int32 >(
 956         entity_->getDirectMandatoryBases().size());
 957     css::uno::Sequence<
 958         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 959     for (sal_Int32 i = 0; i != n; ++i) {
 960         s[i] = manager_->resolve(entity_->getDirectMandatoryBases()[i].name);
 961     }
 962     return s;
 963 }
 964
 965 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 966 InterfaceTypeDescription::getOptionalBaseTypes()
 967 {
 968     assert(entity_->getDirectOptionalBases().size() <= SAL_MAX_INT32);
 969     sal_Int32 n = static_cast< sal_Int32 >(
 970         entity_->getDirectOptionalBases().size());
 971     css::uno::Sequence<
 972         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
 973     for (sal_Int32 i = 0; i != n; ++i) {
 974         s[i] = manager_->resolve(entity_->getDirectOptionalBases()[i].name);
 975     }
 976     return s;
 977 }
 978
 979 class ConstantDescription:
 980     public cppu::WeakImplHelper< css::reflection::XConstantTypeDescription >
 981 {
 982 public:
 983     ConstantDescription(
 984         rtl::OUString const & constantGroupName,
 985         unoidl::ConstantGroupEntity::Member const & member);
 986
 987 private:
 988     virtual ~ConstantDescription() override {}
 989
 990     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
 991     { return css::uno::TypeClass_CONSTANT; }
 992
 993     virtual rtl::OUString SAL_CALL getName() override
 994     { return name_; }
 995
 996     virtual css::uno::Any SAL_CALL getConstantValue() override
 997     { return value_; }
 998
 999     rtl::OUString name_;
1000     css::uno::Any value_;
1001 };
1002
1003 ConstantDescription::ConstantDescription(
1004     rtl::OUString const & constantGroupName,
1005     unoidl::ConstantGroupEntity::Member const & member):
1006     name_(makePrefix(constantGroupName) + member.name)
1007 {
1008     switch (member.value.type) {
1009     case unoidl::ConstantValue::TYPE_BOOLEAN:
1010         value_ <<= member.value.booleanValue;
1011         break;
1012     case unoidl::ConstantValue::TYPE_BYTE:
1013         value_ <<= member.value.byteValue;
1014         break;
1015     case unoidl::ConstantValue::TYPE_SHORT:
1016         value_ <<= member.value.shortValue;
1017         break;
1018     case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
1019         value_ <<= member.value.unsignedShortValue;
1020         break;
1021     case unoidl::ConstantValue::TYPE_LONG:
1022         value_ <<= member.value.longValue;
1023         break;
1024     case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
1025         value_ <<= member.value.unsignedLongValue;
1026         break;
1027     case unoidl::ConstantValue::TYPE_HYPER:
1028         value_ <<= member.value.hyperValue;
1029         break;
1030     case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
1031         value_ <<= member.value.unsignedHyperValue;
1032         break;
1033     case unoidl::ConstantValue::TYPE_FLOAT:
1034         value_ <<= member.value.floatValue;
1035         break;
1036     case unoidl::ConstantValue::TYPE_DOUBLE:
1037         value_ <<= member.value.doubleValue;
1038         break;
1039     default:
1040         for (;;) { std::abort(); } // this cannot happen
1041     }
1042 }
1043
1044 typedef cppu::ImplInheritanceHelper<
1045     PublishableDescription, css::reflection::XConstantsTypeDescription >
1046 ConstantGroupDescription_Base;
1047
1048 class ConstantGroupDescription: public ConstantGroupDescription_Base {
1049 public:
1050     ConstantGroupDescription(
1051         rtl::OUString const & name,
1052         rtl::Reference< unoidl::ConstantGroupEntity > const & entity):
1053         ConstantGroupDescription_Base(entity->isPublished()), name_(name),
1054         entity_(entity)
1055     { assert(entity.is()); }
1056
1057 private:
1058     virtual ~ConstantGroupDescription() override {}
1059
1060     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1061     { return css::uno::TypeClass_CONSTANTS; }
1062
1063     virtual rtl::OUString SAL_CALL getName() override
1064     { return name_; }
1065
1066     virtual
1067     css::uno::Sequence<
1068         css::uno::Reference< css::reflection::XConstantTypeDescription > >
1069     SAL_CALL getConstants() override;
1070
1071     rtl::OUString name_;
1072     rtl::Reference< unoidl::ConstantGroupEntity > entity_;
1073 };
1074
1075 css::uno::Sequence<
1076     css::uno::Reference< css::reflection::XConstantTypeDescription > >
1077 ConstantGroupDescription::getConstants() {
1078     assert(entity_->getMembers().size() <= SAL_MAX_INT32);
1079     sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
1080     css::uno::Sequence<
1081         css::uno::Reference< css::reflection::XConstantTypeDescription > > s(n);
1082     for (sal_Int32 i = 0; i != n; ++i) {
1083         s[i] = new ConstantDescription(name_, entity_->getMembers()[i]);
1084     }
1085     return s;
1086 }
1087
1088 typedef cppu::ImplInheritanceHelper<
1089     PublishableDescription, css::reflection::XIndirectTypeDescription >
1090 TypedefDescription_Base;
1091
1092 class TypedefDescription: public TypedefDescription_Base {
1093 public:
1094     TypedefDescription(
1095         rtl::Reference< cppuhelper::TypeManager > const & manager,
1096         rtl::OUString const & name,
1097         rtl::Reference< unoidl::TypedefEntity > const & entity):
1098         TypedefDescription_Base(entity->isPublished()), manager_(manager),
1099         name_(name), entity_(entity)
1100     { assert(manager.is()); assert(entity.is()); }
1101
1102 private:
1103     virtual ~TypedefDescription() override {}
1104
1105     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1106     { return css::uno::TypeClass_TYPEDEF; }
1107
1108     virtual rtl::OUString SAL_CALL getName() override
1109     { return name_; }
1110
1111     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
1112     getReferencedType() override
1113     { return manager_->resolve(entity_->getType()); }
1114
1115     rtl::Reference< cppuhelper::TypeManager > manager_;
1116     rtl::OUString name_;
1117     rtl::Reference< unoidl::TypedefEntity > entity_;
1118 };
1119
1120 class ConstructorParameter:
1121     public cppu::WeakImplHelper< css::reflection::XParameter >
1122 {
1123 public:
1124     ConstructorParameter(
1125         rtl::Reference< cppuhelper::TypeManager > const & manager,
1126         unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
1127             const & parameter,
1128         sal_Int32 position):
1129         manager_(manager), parameter_(parameter), position_(position)
1130     { assert(manager.is()); }
1131
1132 private:
1133     virtual ~ConstructorParameter() override {}
1134
1135     virtual rtl::OUString SAL_CALL getName() override
1136     { return parameter_.name; }
1137
1138     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
1139     getType() override
1140     { return manager_->resolve(parameter_.type); }
1141
1142     virtual sal_Bool SAL_CALL isIn() override
1143     { return true; }
1144
1145     virtual sal_Bool SAL_CALL isOut() override
1146     { return false; }
1147
1148     virtual sal_Int32 SAL_CALL getPosition() override
1149     { return position_; }
1150
1151     virtual sal_Bool SAL_CALL isRestParameter() override
1152     { return parameter_.rest; }
1153
1154     rtl::Reference< cppuhelper::TypeManager > manager_;
1155     unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
1156         parameter_;
1157     sal_Int32 position_;
1158 };
1159
1160 class ConstructorDescription:
1161     public cppu::WeakImplHelper<
1162         css::reflection::XServiceConstructorDescription >
1163 {
1164 public:
1165     ConstructorDescription(
1166         rtl::Reference< cppuhelper::TypeManager > const & manager,
1167         unoidl::SingleInterfaceBasedServiceEntity::Constructor const &
1168             constructor):
1169         manager_(manager), constructor_(constructor)
1170     { assert(manager.is()); }
1171
1172 private:
1173     virtual ~ConstructorDescription() override {}
1174
1175     virtual sal_Bool SAL_CALL isDefaultConstructor() override
1176     { return constructor_.defaultConstructor; }
1177
1178     virtual rtl::OUString SAL_CALL getName() override
1179     { return constructor_.name; }
1180
1181     virtual
1182     css::uno::Sequence<
1183         css::uno::Reference< css::reflection::XParameter > >
1184     SAL_CALL getParameters() override;
1185
1186     virtual
1187     css::uno::Sequence<
1188         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
1189     SAL_CALL getExceptions() override;
1190
1191     rtl::Reference< cppuhelper::TypeManager > manager_;
1192     unoidl::SingleInterfaceBasedServiceEntity::Constructor constructor_;
1193 };
1194
1195 css::uno::Sequence< css::uno::Reference< css::reflection::XParameter > >
1196 ConstructorDescription::getParameters() {
1197     assert(constructor_.parameters.size() <= SAL_MAX_INT32);
1198     sal_Int32 n = static_cast< sal_Int32 >(constructor_.parameters.size());
1199     css::uno::Sequence< css::uno::Reference< css::reflection::XParameter > > s(
1200         n);
1201     for (sal_Int32 i = 0; i != n; ++i) {
1202         s[i] = new ConstructorParameter(
1203             manager_, constructor_.parameters[i], i);
1204     }
1205     return s;
1206 }
1207
1208 css::uno::Sequence<
1209     css::uno::Reference< css::reflection::XCompoundTypeDescription > >
1210 ConstructorDescription::getExceptions() {
1211     assert(constructor_.exceptions.size() <= SAL_MAX_INT32);
1212     sal_Int32 n = static_cast< sal_Int32 >(constructor_.exceptions.size());
1213     css::uno::Sequence<
1214         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
1215     for (sal_Int32 i = 0; i != n; ++i) {
1216         s[i].set(
1217             manager_->resolve(constructor_.exceptions[i]),
1218             css::uno::UNO_QUERY_THROW);
1219     }
1220     return s;
1221 }
1222
1223 typedef cppu::ImplInheritanceHelper<
1224     PublishableDescription, css::reflection::XServiceTypeDescription2 >
1225 SingleInterfaceBasedServiceDescription_Base;
1226
1227 class SingleInterfaceBasedServiceDescription:
1228     public SingleInterfaceBasedServiceDescription_Base
1229 {
1230 public:
1231     SingleInterfaceBasedServiceDescription(
1232         rtl::Reference< cppuhelper::TypeManager > const & manager,
1233         rtl::OUString const & name,
1234         rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > const &
1235             entity):
1236         SingleInterfaceBasedServiceDescription_Base(entity->isPublished()),
1237         manager_(manager), name_(name), entity_(entity)
1238     { assert(manager.is()); assert(entity.is()); }
1239
1240 private:
1241     virtual ~SingleInterfaceBasedServiceDescription() override {}
1242
1243     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1244     { return css::uno::TypeClass_SERVICE; }
1245
1246     virtual rtl::OUString SAL_CALL getName() override
1247     { return name_; }
1248
1249     virtual
1250     css::uno::Sequence<
1251         css::uno::Reference< css::reflection::XServiceTypeDescription > >
1252     SAL_CALL getMandatoryServices() override
1253     {
1254         return css::uno::Sequence<
1255             css::uno::Reference< css::reflection::XServiceTypeDescription > >();
1256     }
1257
1258     virtual
1259     css::uno::Sequence<
1260         css::uno::Reference< css::reflection::XServiceTypeDescription > >
1261     SAL_CALL getOptionalServices() override
1262     {
1263         return css::uno::Sequence<
1264             css::uno::Reference< css::reflection::XServiceTypeDescription > >();
1265     }
1266
1267     virtual
1268     css::uno::Sequence<
1269         css::uno::Reference< css::reflection::XInterfaceTypeDescription > >
1270     SAL_CALL getMandatoryInterfaces() override
1271     {
1272         return css::uno::Sequence<
1273             css::uno::Reference<
1274                 css::reflection::XInterfaceTypeDescription > >();
1275     }
1276
1277     virtual
1278     css::uno::Sequence<
1279         css::uno::Reference< css::reflection::XInterfaceTypeDescription > >
1280     SAL_CALL getOptionalInterfaces() override
1281     {
1282         return css::uno::Sequence<
1283             css::uno::Reference<
1284                 css::reflection::XInterfaceTypeDescription > >();
1285     }
1286
1287     virtual
1288     css::uno::Sequence<
1289         css::uno::Reference< css::reflection::XPropertyTypeDescription > >
1290     SAL_CALL getProperties() override
1291     {
1292         return css::uno::Sequence<
1293             css::uno::Reference<
1294                 css::reflection::XPropertyTypeDescription > >();
1295     }
1296
1297     virtual sal_Bool SAL_CALL isSingleInterfaceBased() override
1298     { return true; }
1299
1300     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
1301     getInterface() override
1302     { return manager_->resolve(entity_->getBase()); }
1303
1304     virtual
1305     css::uno::Sequence<
1306         css::uno::Reference< css::reflection::XServiceConstructorDescription > >
1307     SAL_CALL getConstructors() override;
1308
1309     rtl::Reference< cppuhelper::TypeManager > manager_;
1310     rtl::OUString name_;
1311     rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > entity_;
1312 };
1313
1314 css::uno::Sequence<
1315     css::uno::Reference< css::reflection::XServiceConstructorDescription > >
1316 SingleInterfaceBasedServiceDescription::getConstructors()
1317 {
1318     assert(entity_->getConstructors().size() <= SAL_MAX_INT32);
1319     sal_Int32 n = static_cast< sal_Int32 >(entity_->getConstructors().size());
1320     css::uno::Sequence<
1321         css::uno::Reference< css::reflection::XServiceConstructorDescription > >
1322             s(n);
1323     for (sal_Int32 i = 0; i != n; ++i) {
1324         s[i] = new ConstructorDescription(
1325             manager_, entity_->getConstructors()[i]);
1326     }
1327     return s;
1328 }
1329
1330 class PropertyDescription:
1331     public cppu::WeakImplHelper< css::reflection::XPropertyTypeDescription >
1332 {
1333 public:
1334     PropertyDescription(
1335         rtl::Reference< cppuhelper::TypeManager > const & manager,
1336         unoidl::AccumulationBasedServiceEntity::Property const & property):
1337         manager_(manager), property_(property)
1338     { assert(manager.is()); }
1339
1340 private:
1341     virtual ~PropertyDescription() override {}
1342
1343     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1344     { return css::uno::TypeClass_PROPERTY; }
1345
1346     virtual rtl::OUString SAL_CALL getName() override
1347     { return property_.name; }
1348
1349     virtual sal_Int16 SAL_CALL getPropertyFlags() override
1350     { return property_.attributes; }
1351
1352     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
1353     getPropertyTypeDescription() override
1354     { return manager_->resolve(property_.type); }
1355
1356     rtl::Reference< cppuhelper::TypeManager > manager_;
1357     unoidl::AccumulationBasedServiceEntity::Property property_;
1358 };
1359
1360 typedef cppu::ImplInheritanceHelper<
1361     PublishableDescription, css::reflection::XServiceTypeDescription2 >
1362 AccumulationBasedServiceDescription_Base;
1363
1364 class AccumulationBasedServiceDescription:
1365     public AccumulationBasedServiceDescription_Base
1366 {
1367 public:
1368     AccumulationBasedServiceDescription(
1369         rtl::Reference< cppuhelper::TypeManager > const & manager,
1370         rtl::OUString const & name,
1371         rtl::Reference< unoidl::AccumulationBasedServiceEntity > const &
1372             entity):
1373         AccumulationBasedServiceDescription_Base(entity->isPublished()),
1374         manager_(manager), name_(name), entity_(entity)
1375     { assert(manager.is()); assert(entity.is()); }
1376
1377 private:
1378     virtual ~AccumulationBasedServiceDescription() override {}
1379
1380     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1381     { return css::uno::TypeClass_SERVICE; }
1382
1383     virtual rtl::OUString SAL_CALL getName() override
1384     { return name_; }
1385
1386     virtual
1387     css::uno::Sequence<
1388         css::uno::Reference< css::reflection::XServiceTypeDescription > >
1389     SAL_CALL getMandatoryServices() override;
1390
1391     virtual
1392     css::uno::Sequence<
1393         css::uno::Reference< css::reflection::XServiceTypeDescription > >
1394     SAL_CALL getOptionalServices() override;
1395
1396     virtual
1397     css::uno::Sequence<
1398         css::uno::Reference< css::reflection::XInterfaceTypeDescription > >
1399     SAL_CALL getMandatoryInterfaces() override;
1400
1401     virtual
1402     css::uno::Sequence<
1403         css::uno::Reference< css::reflection::XInterfaceTypeDescription > >
1404     SAL_CALL getOptionalInterfaces() override;
1405
1406     virtual
1407     css::uno::Sequence<
1408         css::uno::Reference< css::reflection::XPropertyTypeDescription > >
1409     SAL_CALL getProperties() override;
1410
1411     virtual sal_Bool SAL_CALL isSingleInterfaceBased() override
1412     { return false; }
1413
1414     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
1415     getInterface() override
1416     { return css::uno::Reference< css::reflection::XTypeDescription >(); }
1417
1418     virtual
1419     css::uno::Sequence<
1420         css::uno::Reference< css::reflection::XServiceConstructorDescription > >
1421     SAL_CALL getConstructors() override
1422     {
1423         return css::uno::Sequence<
1424             css::uno::Reference<
1425                 css::reflection::XServiceConstructorDescription > >();
1426     }
1427
1428     rtl::Reference< cppuhelper::TypeManager > manager_;
1429     rtl::OUString name_;
1430     rtl::Reference< unoidl::AccumulationBasedServiceEntity > entity_;
1431 };
1432
1433 css::uno::Sequence<
1434     css::uno::Reference< css::reflection::XServiceTypeDescription > >
1435 AccumulationBasedServiceDescription::getMandatoryServices()
1436 {
1437     assert(entity_->getDirectMandatoryBaseServices().size() <= SAL_MAX_INT32);
1438     sal_Int32 n = static_cast< sal_Int32 >(
1439         entity_->getDirectMandatoryBaseServices().size());
1440     css::uno::Sequence<
1441         css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
1442     for (sal_Int32 i = 0; i != n; ++i) {
1443         s[i].set(
1444             manager_->resolve(
1445                 entity_->getDirectMandatoryBaseServices()[i].name),
1446             css::uno::UNO_QUERY_THROW);
1447     }
1448     return s;
1449 }
1450
1451 css::uno::Sequence<
1452     css::uno::Reference< css::reflection::XServiceTypeDescription > >
1453 AccumulationBasedServiceDescription::getOptionalServices()
1454 {
1455     assert(entity_->getDirectOptionalBaseServices().size() <= SAL_MAX_INT32);
1456     sal_Int32 n = static_cast< sal_Int32 >(
1457         entity_->getDirectOptionalBaseServices().size());
1458     css::uno::Sequence<
1459         css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
1460     for (sal_Int32 i = 0; i != n; ++i) {
1461         s[i].set(
1462             manager_->resolve(entity_->getDirectOptionalBaseServices()[i].name),
1463             css::uno::UNO_QUERY_THROW);
1464     }
1465     return s;
1466 }
1467
1468 css::uno::Sequence<
1469     css::uno::Reference< css::reflection::XInterfaceTypeDescription > >
1470 AccumulationBasedServiceDescription::getMandatoryInterfaces()
1471 {
1472     assert(entity_->getDirectMandatoryBaseInterfaces().size() <= SAL_MAX_INT32);
1473     sal_Int32 n = static_cast< sal_Int32 >(
1474         entity_->getDirectMandatoryBaseInterfaces().size());
1475     css::uno::Sequence<
1476         css::uno::Reference< css::reflection::XInterfaceTypeDescription > > s(
1477             n);
1478     for (sal_Int32 i = 0; i != n; ++i) {
1479         s[i].set(
1480             resolveTypedefs(
1481                 manager_->find(
1482                     entity_->getDirectMandatoryBaseInterfaces()[i].name)),
1483             css::uno::UNO_QUERY_THROW);
1484     }
1485     return s;
1486 }
1487
1488 css::uno::Sequence<
1489     css::uno::Reference< css::reflection::XInterfaceTypeDescription > >
1490 AccumulationBasedServiceDescription::getOptionalInterfaces()
1491 {
1492     assert(entity_->getDirectOptionalBaseInterfaces().size() <= SAL_MAX_INT32);
1493     sal_Int32 n = static_cast< sal_Int32 >(
1494         entity_->getDirectOptionalBaseInterfaces().size());
1495     css::uno::Sequence<
1496         css::uno::Reference< css::reflection::XInterfaceTypeDescription > > s(
1497             n);
1498     for (sal_Int32 i = 0; i != n; ++i) {
1499         s[i].set(
1500             resolveTypedefs(
1501                 manager_->find(
1502                     entity_->getDirectOptionalBaseInterfaces()[i].name)),
1503             css::uno::UNO_QUERY_THROW);
1504     }
1505     return s;
1506 }
1507
1508 css::uno::Sequence<
1509     css::uno::Reference< css::reflection::XPropertyTypeDescription > >
1510 AccumulationBasedServiceDescription::getProperties()
1511 {
1512     assert(entity_->getDirectProperties().size() <= SAL_MAX_INT32);
1513     sal_Int32 n = static_cast< sal_Int32 >(
1514         entity_->getDirectProperties().size());
1515     css::uno::Sequence<
1516         css::uno::Reference< css::reflection::XPropertyTypeDescription > > s(n);
1517     for (sal_Int32 i = 0; i != n; ++i) {
1518         s[i] = new PropertyDescription(
1519             manager_, entity_->getDirectProperties()[i]);
1520     }
1521     return s;
1522 }
1523
1524 typedef cppu::ImplInheritanceHelper<
1525     PublishableDescription, css::reflection::XSingletonTypeDescription2 >
1526 InterfaceBasedSingletonDescription_Base;
1527
1528 class InterfaceBasedSingletonDescription:
1529     public InterfaceBasedSingletonDescription_Base
1530 {
1531 public:
1532     InterfaceBasedSingletonDescription(
1533         rtl::Reference< cppuhelper::TypeManager > const & manager,
1534         rtl::OUString const & name,
1535         rtl::Reference< unoidl::InterfaceBasedSingletonEntity > const & entity):
1536         InterfaceBasedSingletonDescription_Base(entity->isPublished()),
1537         manager_(manager), name_(name), entity_(entity)
1538     { assert(manager.is()); assert(entity.is()); }
1539
1540 private:
1541     virtual ~InterfaceBasedSingletonDescription() override {}
1542
1543     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1544     { return css::uno::TypeClass_SINGLETON; }
1545
1546     virtual rtl::OUString SAL_CALL getName() override
1547     { return name_; }
1548
1549     virtual css::uno::Reference< css::reflection::XServiceTypeDescription >
1550     SAL_CALL getService() override
1551     {
1552         return
1553             css::uno::Reference< css::reflection::XServiceTypeDescription >();
1554     }
1555
1556     virtual sal_Bool SAL_CALL isInterfaceBased() override
1557     { return true; }
1558
1559     virtual css::uno::Reference< css::reflection::XTypeDescription >
1560     SAL_CALL getInterface() override
1561     { return manager_->resolve(entity_->getBase()); }
1562
1563     rtl::Reference< cppuhelper::TypeManager > manager_;
1564     rtl::OUString name_;
1565     rtl::Reference< unoidl::InterfaceBasedSingletonEntity > entity_;
1566 };
1567
1568 typedef cppu::ImplInheritanceHelper<
1569     PublishableDescription, css::reflection::XSingletonTypeDescription2 >
1570 ServiceBasedSingletonDescription_Base;
1571
1572 class ServiceBasedSingletonDescription:
1573     public ServiceBasedSingletonDescription_Base
1574 {
1575 public:
1576     ServiceBasedSingletonDescription(
1577         rtl::Reference< cppuhelper::TypeManager > const & manager,
1578         rtl::OUString const & name,
1579         rtl::Reference< unoidl::ServiceBasedSingletonEntity > const & entity):
1580         ServiceBasedSingletonDescription_Base(entity_->isPublished()),
1581         manager_(manager), name_(name), entity_(entity)
1582     { assert(manager.is()); assert(entity.is()); }
1583
1584 private:
1585     virtual ~ServiceBasedSingletonDescription() override {}
1586
1587     virtual css::uno::TypeClass SAL_CALL getTypeClass() override
1588     { return css::uno::TypeClass_SINGLETON; }
1589
1590     virtual rtl::OUString SAL_CALL getName() override
1591     { return name_; }
1592
1593     virtual css::uno::Reference< css::reflection::XServiceTypeDescription >
1594     SAL_CALL getService() override
1595     {
1596         return css::uno::Reference< css::reflection::XServiceTypeDescription >(
1597             manager_->resolve(entity_->getBase()), css::uno::UNO_QUERY_THROW);
1598     }
1599
1600     virtual sal_Bool SAL_CALL isInterfaceBased() override
1601     { return false; }
1602
1603     virtual css::uno::Reference< css::reflection::XTypeDescription >
1604     SAL_CALL getInterface() override
1605     { return css::uno::Reference< css::reflection::XTypeDescription >(); }
1606
1607     rtl::Reference< cppuhelper::TypeManager > manager_;
1608     rtl::OUString name_;
1609     rtl::Reference< unoidl::ServiceBasedSingletonEntity > entity_;
1610 };
1611
1612 class Enumeration:
1613     public cppu::WeakImplHelper< css::reflection::XTypeDescriptionEnumeration >
1614 {
1615 public:
1616     Enumeration(
1617         rtl::Reference< cppuhelper::TypeManager > const & manager,
1618         rtl::OUString const & prefix,
1619         rtl::Reference< unoidl::MapCursor > const & cursor,
1620         css::uno::Sequence< css::uno::TypeClass > const & types, bool deep):
1621         manager_(manager), types_(types), deep_(deep)
1622     {
1623         assert(manager.is());
1624         positions_.push(Position(prefix, cursor));
1625         findNextMatch();
1626     }
1627
1628 private:
1629     virtual ~Enumeration() override {}
1630
1631     virtual sal_Bool SAL_CALL hasMoreElements() override
1632     { return !positions_.empty(); }
1633
1634     virtual css::uno::Any SAL_CALL nextElement() override
1635     { return css::uno::makeAny(nextTypeDescription()); }
1636
1637     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
1638     nextTypeDescription() override;
1639
1640     bool matches(css::uno::TypeClass tc) const;
1641
1642     void findNextMatch();
1643
1644     struct Position {
1645         Position(
1646             rtl::OUString const & thePrefix,
1647             rtl::Reference< unoidl::MapCursor > const & theCursor):
1648             prefix(thePrefix), cursor(theCursor)
1649         { assert(theCursor.is()); }
1650
1651         Position(
1652             rtl::OUString const & thePrefix,
1653             rtl::Reference< unoidl::ConstantGroupEntity > const &
1654                 theConstantGroup):
1655             prefix(thePrefix), constantGroup(theConstantGroup),
1656             constantGroupIndex(constantGroup->getMembers().begin())
1657         { assert(theConstantGroup.is()); }
1658
1659         Position(Position const & other):
1660             prefix(other.prefix), cursor(other.cursor),
1661             constantGroup(other.constantGroup)
1662         {
1663             if (constantGroup.is()) {
1664                 constantGroupIndex = other.constantGroupIndex;
1665             }
1666         }
1667
1668         rtl::OUString prefix;
1669         rtl::Reference< unoidl::MapCursor > cursor;
1670         rtl::Reference< unoidl::ConstantGroupEntity > constantGroup;
1671         std::vector< unoidl::ConstantGroupEntity::Member >::const_iterator
1672             constantGroupIndex;
1673     };
1674
1675     rtl::Reference< cppuhelper::TypeManager > manager_;
1676     css::uno::Sequence< css::uno::TypeClass > types_;
1677     bool deep_;
1678
1679     osl::Mutex mutex_;
1680     std::stack< Position > positions_;
1681     rtl::OUString current_;
1682 };
1683
1684 css::uno::Reference< css::reflection::XTypeDescription >
1685 Enumeration::nextTypeDescription()
1686 {
1687     rtl::OUString name;
1688     {
1689         osl::MutexGuard g(mutex_);
1690         if (positions_.empty()) {
1691             throw css::container::NoSuchElementException(
1692                 "exhausted XTypeDescriptionEnumeration",
1693                 static_cast< cppu::OWeakObject * >(this));
1694         }
1695         name = current_;
1696         findNextMatch();
1697     }
1698     return manager_->resolve(name);
1699 }
1700
1701 bool Enumeration::matches(css::uno::TypeClass tc) const {
1702     if (types_.getLength() == 0) {
1703         return true;
1704     }
1705     for (sal_Int32 i = 0; i != types_.getLength(); ++i) {
1706         if (types_[i] == tc) {
1707             return true;
1708         }
1709     }
1710     return false;
1711 }
1712
1713 void Enumeration::findNextMatch() {
1714     try {
1715         for (;;) {
1716             assert(!positions_.empty());
1717             rtl::OUString name;
1718             if (positions_.top().cursor.is()) { // root or module
1719                 rtl::Reference< unoidl::Entity > ent(
1720                     positions_.top().cursor->getNext(&name));
1721                 if (!ent.is()) {
1722                     positions_.pop();
1723                     if (positions_.empty()) {
1724                         break;
1725                     }
1726                     continue;
1727                 }
1728                 name = positions_.top().prefix + name;
1729                 css::uno::TypeClass tc;
1730                 switch (ent->getSort()) {
1731                 case unoidl::Entity::SORT_MODULE:
1732                     tc = css::uno::TypeClass_MODULE;
1733                     if (deep_) {
1734                         positions_.push(
1735                             Position(
1736                                 makePrefix(name),
1737                                 static_cast< unoidl::ModuleEntity * >(
1738                                     ent.get())->createCursor()));
1739                     }
1740                     break;
1741                 case unoidl::Entity::SORT_ENUM_TYPE:
1742                     tc = css::uno::TypeClass_ENUM;
1743                     break;
1744                 case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
1745                 case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
1746                     tc = css::uno::TypeClass_STRUCT;
1747                     break;
1748                 case unoidl::Entity::SORT_EXCEPTION_TYPE:
1749                     tc = css::uno::TypeClass_EXCEPTION;
1750                     break;
1751                 case unoidl::Entity::SORT_INTERFACE_TYPE:
1752                     tc = css::uno::TypeClass_INTERFACE;
1753                     break;
1754                 case unoidl::Entity::SORT_TYPEDEF:
1755                     tc = css::uno::TypeClass_TYPEDEF;
1756                     break;
1757                 case unoidl::Entity::SORT_CONSTANT_GROUP:
1758                     tc = css::uno::TypeClass_CONSTANTS;
1759                     if (deep_ && matches(css::uno::TypeClass_CONSTANT)) {
1760                         positions_.push(
1761                             Position(
1762                                 makePrefix(name),
1763                                 static_cast< unoidl::ConstantGroupEntity * >(
1764                                     ent.get())));
1765                     }
1766                     break;
1767                 case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
1768                 case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
1769                     tc = css::uno::TypeClass_SERVICE;
1770                     break;
1771                 case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
1772                 case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
1773                     tc = css::uno::TypeClass_SINGLETON;
1774                     break;
1775                 default:
1776                     for (;;) { std::abort(); } // this cannot happen
1777                 }
1778                 if (matches(tc)) {
1779                     current_ = name;
1780                     break;
1781                 }
1782             } else { // constant group
1783                 if (positions_.top().constantGroupIndex
1784                     == positions_.top().constantGroup->getMembers().end())
1785                 {
1786                     positions_.pop();
1787                     if (positions_.empty()) {
1788                         break;
1789                     }
1790                     continue;
1791                 }
1792                 current_ = positions_.top().prefix
1793                     + positions_.top().constantGroupIndex++->name;
1794                 break;
1795             }
1796         }
1797     } catch (unoidl::FileFormatException & e) {
1798         throw css::uno::DeploymentException(
1799             e.getUri() + ": " + e.getDetail(),
1800             static_cast< cppu::OWeakObject * >(this));
1801     }
1802 }
1803
1804 }
1805
1806 cppuhelper::TypeManager::TypeManager():
1807     TypeManager_Base(m_aMutex),
1808     manager_(new unoidl::Manager)
1809 {}
1810
1811 css::uno::Any cppuhelper::TypeManager::find(rtl::OUString const & name) {
1812     //TODO: caching? (here or in unoidl::Manager?)
1813     struct Simple {
1814         OUStringLiteral name;
1815         css::uno::TypeClass typeClass;
1816     };
1817     static Simple const simple[] = {
1818         { OUStringLiteral("void"), css::uno::TypeClass_VOID },
1819         { OUStringLiteral("boolean"), css::uno::TypeClass_BOOLEAN },
1820         { OUStringLiteral("byte"), css::uno::TypeClass_BYTE },
1821         { OUStringLiteral("short"), css::uno::TypeClass_SHORT },
1822         { OUStringLiteral("unsigned short"),
1823           css::uno::TypeClass_UNSIGNED_SHORT },
1824         { OUStringLiteral("long"), css::uno::TypeClass_LONG },
1825         { OUStringLiteral("unsigned long"), css::uno::TypeClass_UNSIGNED_LONG },
1826         { OUStringLiteral("hyper"), css::uno::TypeClass_HYPER },
1827         { OUStringLiteral("unsigned hyper"),
1828           css::uno::TypeClass_UNSIGNED_HYPER },
1829         { OUStringLiteral("float"), css::uno::TypeClass_FLOAT },
1830         { OUStringLiteral("double"), css::uno::TypeClass_DOUBLE },
1831         { OUStringLiteral("char"), css::uno::TypeClass_CHAR },
1832         { OUStringLiteral("string"), css::uno::TypeClass_STRING },
1833         { OUStringLiteral("type"), css::uno::TypeClass_TYPE },
1834         { OUStringLiteral("any"), css::uno::TypeClass_ANY } };
1835     for (std::size_t i = 0; i != SAL_N_ELEMENTS(simple); ++i) {
1836         if (name == simple[i].name) {
1837             return css::uno::makeAny<
1838                 css::uno::Reference< css::reflection::XTypeDescription > >(
1839                     new SimpleTypeDescription(simple[i].typeClass, name));
1840         }
1841     }
1842     if (name.startsWith("[]")) {
1843         return getSequenceType(name);
1844     }
1845     sal_Int32 i = name.indexOf('<');
1846     if (i != -1) {
1847         return getInstantiatedStruct(name, i);
1848     }
1849     i = name.indexOf("::");
1850     if (i != -1) {
1851         return getInterfaceMember(name, i);
1852     }
1853     rtl::Reference< unoidl::Entity > ent(findEntity(name));
1854     if (ent.is()) {
1855         return getNamed(name, ent);
1856     }
1857     i = name.lastIndexOf('.');
1858     if (i != -1) {
1859         rtl::OUString parent(name.copy(0, i));
1860         ent = findEntity(parent);
1861         if (ent.is()) {
1862             switch (ent->getSort()) {
1863             case unoidl::Entity::SORT_ENUM_TYPE:
1864                 return getEnumMember(
1865                     static_cast< unoidl::EnumTypeEntity * >(ent.get()),
1866                     name.copy(i + 1));
1867             case unoidl::Entity::SORT_CONSTANT_GROUP:
1868                 return getConstant(
1869                     parent,
1870                     static_cast< unoidl::ConstantGroupEntity * >(ent.get()),
1871                     name.copy(i + 1));
1872             default:
1873                 break;
1874             }
1875         }
1876     }
1877     return css::uno::Any();
1878 }
1879
1880 css::uno::Reference< css::reflection::XTypeDescription >
1881 cppuhelper::TypeManager::resolve(rtl::OUString const & name) {
1882     css::uno::Reference< css::reflection::XTypeDescription > desc(
1883         find(name), css::uno::UNO_QUERY);
1884     if (!desc.is()) {
1885         throw css::uno::DeploymentException(
1886             "cannot resolve type \"" + name + "\"",
1887             static_cast< cppu::OWeakObject * >(this));
1888     }
1889     return desc;
1890 }
1891
1892 cppuhelper::TypeManager::~TypeManager() throw () {}
1893
1894 void cppuhelper::TypeManager::disposing() {} //TODO
1895
1896 rtl::OUString cppuhelper::TypeManager::getImplementationName()
1897 {
1898     return rtl::OUString(
1899         "com.sun.star.comp.cppuhelper.bootstrap.TypeManager");
1900 }
1901
1902 sal_Bool cppuhelper::TypeManager::supportsService(
1903     rtl::OUString const & ServiceName)
1904 {
1905     return cppu::supportsService(this, ServiceName);
1906 }
1907
1908 css::uno::Sequence< rtl::OUString >
1909 cppuhelper::TypeManager::getSupportedServiceNames()
1910 {
1911     css::uno::Sequence<OUString> names { "com.sun.star.reflection.TypeDescriptionManager" }; //TODO
1912     return names;
1913 }
1914
1915 css::uno::Any cppuhelper::TypeManager::getByHierarchicalName(
1916     rtl::OUString const & aName)
1917 {
1918     css::uno::Any desc(find(aName));
1919     if (!desc.hasValue()) {
1920         throw css::container::NoSuchElementException(
1921             aName, static_cast< cppu::OWeakObject * >(this));
1922     }
1923     return desc;
1924 }
1925
1926 sal_Bool cppuhelper::TypeManager::hasByHierarchicalName(
1927     rtl::OUString const & aName)
1928 {
1929     return find(aName).hasValue();
1930 }
1931
1932 css::uno::Type cppuhelper::TypeManager::getElementType()
1933 {
1934     return cppu::UnoType< rtl::OUString >::get();
1935 }
1936
1937 sal_Bool cppuhelper::TypeManager::hasElements()
1938 {
1939     throw css::uno::RuntimeException(
1940         "TypeManager hasElements: method not supported",
1941         static_cast< cppu::OWeakObject * >(this));
1942 }
1943
1944 css::uno::Reference< css::container::XEnumeration >
1945 cppuhelper::TypeManager::createEnumeration()
1946 {
1947     throw css::uno::RuntimeException(
1948         "TypeManager createEnumeration: method not supported",
1949         static_cast< cppu::OWeakObject * >(this));
1950 }
1951
1952 sal_Bool cppuhelper::TypeManager::has(css::uno::Any const &)
1953 {
1954     throw css::uno::RuntimeException(
1955         "TypeManager has: method not supported",
1956         static_cast< cppu::OWeakObject * >(this));
1957 }
1958
1959 void cppuhelper::TypeManager::insert(css::uno::Any const & aElement)
1960 {
1961     rtl::OUString uri;
1962     if (!(aElement >>= uri)) {
1963         throw css::lang::IllegalArgumentException(
1964             ("css.uno.theTypeDescriptionManager.insert expects a string URI"
1965              " argument"),
1966             static_cast< cppu::OWeakObject * >(this), 0);
1967     }
1968     //TODO: check for ElementExistException
1969     //TODO: check for consistency with existing data
1970     readRdbFile(uri, false);
1971 }
1972
1973 void cppuhelper::TypeManager::remove(css::uno::Any const & aElement)
1974 {
1975     rtl::OUString uri;
1976     if (!(aElement >>= uri)) {
1977         throw css::lang::IllegalArgumentException(
1978             ("css.uno.theTypeDescriptionManager.remove expects a string URI"
1979              " argument"),
1980             static_cast< cppu::OWeakObject * >(this), 0);
1981     }
1982     //TODO: remove requests are silently ignored for now
1983 }
1984
1985 css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
1986 cppuhelper::TypeManager::createTypeDescriptionEnumeration(
1987     rtl::OUString const & moduleName,
1988     css::uno::Sequence< css::uno::TypeClass > const & types,
1989     css::reflection::TypeDescriptionSearchDepth depth)
1990 {
1991     rtl::Reference< unoidl::MapCursor > cursor;
1992     try {
1993         cursor = manager_->createCursor(moduleName);
1994     } catch (unoidl::FileFormatException & e) {
1995         throw css::uno::DeploymentException(
1996             ("unoidl::FileFormatException for <" + e.getUri() + ">: "
1997              + e.getDetail()),
1998             static_cast< cppu::OWeakObject * >(this));
1999     }
2000     if (!cursor.is()) {
2001         //TODO: css::reflection::InvalidTypeNameException if moduleName names a
2002         // non-module
2003         throw css::reflection::NoSuchTypeNameException(
2004             moduleName, static_cast< cppu::OWeakObject * >(this));
2005     }
2006     return new Enumeration(
2007         this, makePrefix(moduleName), cursor, types,
2008         depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
2009 }
2010
2011 void cppuhelper::TypeManager::init(rtl::OUString const & rdbUris) {
2012     for (sal_Int32 i = 0; i != -1;) {
2013         rtl::OUString uri(rdbUris.getToken(0, ' ', i));
2014         if (uri.isEmpty()) {
2015             continue;
2016         }
2017         bool optional;
2018         bool directory;
2019         cppu::decodeRdbUri(&uri, &optional, &directory);
2020         if (directory) {
2021             readRdbDirectory(uri, optional);
2022         } else {
2023             readRdbFile(uri, optional);
2024         }
2025     }
2026 }
2027
2028 void cppuhelper::TypeManager::readRdbDirectory(
2029     rtl::OUString const & uri, bool optional)
2030 {
2031     osl::Directory dir(uri);
2032     switch (dir.open()) {
2033     case osl::FileBase::E_None:
2034         break;
2035     case osl::FileBase::E_NOENT:
2036         if (optional) {
2037             SAL_INFO("cppuhelper", "Ignored optional " << uri);
2038             return;
2039         }
2040         SAL_FALLTHROUGH;
2041     default:
2042         throw css::uno::DeploymentException(
2043             "Cannot open directory " + uri,
2044             static_cast< cppu::OWeakObject * >(this));
2045     }
2046     for (;;) {
2047         rtl::OUString url;
2048         if (!cppu::nextDirectoryItem(dir, &url)) {
2049             break;
2050         }
2051         readRdbFile(url, false);
2052     }
2053 }
2054
2055 void cppuhelper::TypeManager::readRdbFile(
2056     rtl::OUString const & uri, bool optional)
2057 {
2058     try {
2059         manager_->addProvider(uri);
2060     } catch (unoidl::NoSuchFileException &) {
2061         if (!optional) {
2062             throw css::uno::DeploymentException(
2063                 uri + ": no such file",
2064                 static_cast< cppu::OWeakObject * >(this));
2065         }
2066         SAL_INFO("cppuhelper", "Ignored optional " << uri);
2067     } catch (unoidl::FileFormatException & e) {
2068             throw css::uno::DeploymentException(
2069                 ("unoidl::FileFormatException for <" + e.getUri() + ">: "
2070                  + e.getDetail()),
2071                 static_cast< cppu::OWeakObject * >(this));
2072     }
2073 }
2074
2075 css::uno::Any cppuhelper::TypeManager::getSequenceType(
2076     rtl::OUString const & name)
2077 {
2078     assert(name.startsWith("[]"));
2079     return css::uno::makeAny<
2080         css::uno::Reference< css::reflection::XTypeDescription > >(
2081             new SequenceTypeDescription(
2082                 this, name, name.copy(std::strlen("[]"))));
2083 }
2084
2085 css::uno::Any cppuhelper::TypeManager::getInstantiatedStruct(
2086     rtl::OUString const & name, sal_Int32 separator)
2087 {
2088     assert(name.indexOf('<') == separator && separator != -1);
2089     rtl::Reference< unoidl::Entity > ent(findEntity(name.copy(0, separator)));
2090     if (!ent.is()
2091         || (ent->getSort()
2092             != unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE))
2093     {
2094         return css::uno::Any();
2095     }
2096     rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > ent2(
2097         static_cast< unoidl::PolymorphicStructTypeTemplateEntity * >(
2098             ent.get()));
2099     std::vector< rtl::OUString > args;
2100     sal_Int32 i = separator;
2101     do {
2102         ++i; // skip '<' or ','
2103         sal_Int32 j = i;
2104         for (sal_Int32 level = 0; j != name.getLength(); ++j) {
2105             sal_Unicode c = name[j];
2106             if (c == ',') {
2107                 if (level == 0) {
2108                     break;
2109                 }
2110             } else if (c == '<') {
2111                 ++level;
2112             } else if (c == '>') {
2113                 if (level == 0) {
2114                     break;
2115                 }
2116                 --level;
2117             }
2118         }
2119         if (j != name.getLength()) {
2120             args.push_back(name.copy(i, j - i));
2121         }
2122         i = j;
2123     } while (i != name.getLength() && name[i] != '>');
2124     if (i != name.getLength() - 1 || name[i] != '>'
2125         || args.size() != ent2->getTypeParameters().size())
2126     {
2127         return css::uno::Any();
2128     }
2129     return css::uno::makeAny<
2130         css::uno::Reference< css::reflection::XTypeDescription > >(
2131             new InstantiatedPolymorphicStructTypeDescription(
2132                 this, name, ent2, args));
2133 }
2134
2135 css::uno::Any cppuhelper::TypeManager::getInterfaceMember(
2136     rtl::OUString const & name, sal_Int32 separator)
2137 {
2138     assert(name.indexOf("::") == separator && separator != -1);
2139     css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > ifc(
2140         resolveTypedefs(find(name.copy(0, separator))), css::uno::UNO_QUERY);
2141     if (!ifc.is()) {
2142         return css::uno::Any();
2143     }
2144     rtl::OUString member(name.copy(separator + std::strlen("::")));
2145     css::uno::Sequence<
2146         css::uno::Reference<
2147             css::reflection::XInterfaceMemberTypeDescription > > mems(
2148                 ifc->getMembers());
2149     for (sal_Int32 i = 0; i != mems.getLength(); ++i) {
2150         if (mems[i]->getMemberName() == member) {
2151             return css::uno::makeAny<
2152                 css::uno::Reference< css::reflection::XTypeDescription > >(
2153                     mems[i]);
2154         }
2155     }
2156     return css::uno::Any();
2157 }
2158
2159 css::uno::Any cppuhelper::TypeManager::getNamed(
2160     rtl::OUString const & name, rtl::Reference< unoidl::Entity > const & entity)
2161 {
2162     assert(entity.is());
2163     switch (entity->getSort()) {
2164     case unoidl::Entity::SORT_MODULE:
2165         return css::uno::makeAny<
2166             css::uno::Reference< css::reflection::XTypeDescription > >(
2167                 new ModuleDescription(
2168                     this, name,
2169                     static_cast< unoidl::ModuleEntity * >(entity.get())));
2170     case unoidl::Entity::SORT_ENUM_TYPE:
2171         return css::uno::makeAny<
2172             css::uno::Reference< css::reflection::XTypeDescription > >(
2173                 new EnumTypeDescription(
2174                     name,
2175                     static_cast< unoidl::EnumTypeEntity * >(entity.get())));
2176     case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
2177         return css::uno::makeAny<
2178             css::uno::Reference< css::reflection::XTypeDescription > >(
2179                 new PlainStructTypeDescription(
2180                     this, name,
2181                     static_cast< unoidl::PlainStructTypeEntity * >(
2182                         entity.get())));
2183     case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
2184         return css::uno::makeAny<
2185             css::uno::Reference< css::reflection::XTypeDescription > >(
2186                 new PolymorphicStructTypeTemplateDescription(
2187                     this, name,
2188                     static_cast<
2189                         unoidl::PolymorphicStructTypeTemplateEntity * >(
2190                             entity.get())));
2191     case unoidl::Entity::SORT_EXCEPTION_TYPE:
2192         return css::uno::makeAny<
2193             css::uno::Reference< css::reflection::XTypeDescription > >(
2194                 new ExceptionTypeDescription(
2195                     this, name,
2196                     static_cast< unoidl::ExceptionTypeEntity * >(
2197                         entity.get())));
2198     case unoidl::Entity::SORT_INTERFACE_TYPE:
2199         return css::uno::makeAny<
2200             css::uno::Reference< css::reflection::XTypeDescription > >(
2201                 new InterfaceTypeDescription(
2202                     this, name,
2203                     static_cast< unoidl::InterfaceTypeEntity * >(
2204                         entity.get())));
2205     case unoidl::Entity::SORT_TYPEDEF:
2206         return css::uno::makeAny<
2207             css::uno::Reference< css::reflection::XTypeDescription > >(
2208                 new TypedefDescription(
2209                     this, name,
2210                     static_cast< unoidl::TypedefEntity * >(entity.get())));
2211     case unoidl::Entity::SORT_CONSTANT_GROUP:
2212         return css::uno::makeAny<
2213             css::uno::Reference< css::reflection::XTypeDescription > >(
2214                 new ConstantGroupDescription(
2215                     name,
2216                     static_cast< unoidl::ConstantGroupEntity * >(
2217                         entity.get())));
2218     case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
2219         return css::uno::makeAny<
2220             css::uno::Reference< css::reflection::XTypeDescription > >(
2221                 new SingleInterfaceBasedServiceDescription(
2222                     this, name,
2223                     static_cast< unoidl::SingleInterfaceBasedServiceEntity * >(
2224                         entity.get())));
2225     case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
2226         return css::uno::makeAny<
2227             css::uno::Reference< css::reflection::XTypeDescription > >(
2228                 new AccumulationBasedServiceDescription(
2229                     this, name,
2230                     static_cast< unoidl::AccumulationBasedServiceEntity * >(
2231                         entity.get())));
2232     case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
2233         return css::uno::makeAny<
2234             css::uno::Reference< css::reflection::XTypeDescription > >(
2235                 new InterfaceBasedSingletonDescription(
2236                     this, name,
2237                     static_cast< unoidl::InterfaceBasedSingletonEntity * >(
2238                         entity.get())));
2239     case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
2240         return css::uno::makeAny<
2241             css::uno::Reference< css::reflection::XTypeDescription > >(
2242                 new ServiceBasedSingletonDescription(
2243                     this, name,
2244                     static_cast< unoidl::ServiceBasedSingletonEntity * >(
2245                         entity.get())));
2246     default:
2247         for (;;) { std::abort(); } // this cannot happen
2248     }
2249 }
2250
2251 css::uno::Any cppuhelper::TypeManager::getEnumMember(
2252     rtl::Reference< unoidl::EnumTypeEntity > const & entity,
2253     rtl::OUString const & member)
2254 {
2255     for (std::vector< unoidl::EnumTypeEntity::Member >::const_iterator i(
2256              entity->getMembers().begin());
2257          i != entity->getMembers().end(); ++i)
2258     {
2259         if (i->name == member) {
2260             return css::uno::makeAny(i->value);
2261         }
2262     }
2263     return css::uno::Any();
2264 }
2265
2266 css::uno::Any cppuhelper::TypeManager::getConstant(
2267     rtl::OUString const & constantGroupName,
2268     rtl::Reference< unoidl::ConstantGroupEntity > const & entity,
2269     rtl::OUString const & member)
2270 {
2271     for (std::vector< unoidl::ConstantGroupEntity::Member >::const_iterator i(
2272              entity->getMembers().begin());
2273          i != entity->getMembers().end(); ++i)
2274     {
2275         if (i->name == member) {
2276             return css::uno::makeAny<
2277                 css::uno::Reference< css::reflection::XTypeDescription > >(
2278                     new ConstantDescription(constantGroupName, *i));
2279         }
2280     }
2281     return css::uno::Any();
2282 }
2283
2284 rtl::Reference< unoidl::Entity > cppuhelper::TypeManager::findEntity(
2285     rtl::OUString const & name)
2286 {
2287     try {
2288         return manager_->findEntity(name);
2289     } catch (unoidl::FileFormatException & e) {
2290         throw css::uno::DeploymentException(
2291             ("unoidl::FileFormatException for <" + e.getUri() + ">: "
2292              + e.getDetail()),
2293             static_cast< cppu::OWeakObject * >(this));
2294     }
2295 }
2296
2297 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */