Revert "Revert "WIP: Experimental new binary type.rdb format""

This reverts commit 67e69a55820f50973ca0de75ccab2bb07d0bada8, applying a band-
aid fix to cli_ure/source/climaker for now.

Conflicts:
stoc/inc/bootstrapservices.hxx
stoc/source/tdmanager/lrucache.hxx
stoc/source/tdmanager/tdmgr.cxx
stoc/source/tdmanager/tdmgr_common.hxx
stoc/source/tdmanager/tdmgr_tdenumeration.cxx
stoc/source/tdmanager/tdmgr_tdenumeration.hxx

Change-Id: Iae669985d0194f06fa349a4a39f0ebd230bc5d28

19 files changed, 1035 insertions, 2899 deletions

diff --git a/cli_ure/source/climaker/climaker_app.cxx b/cli_ure/source/climaker/climaker_app.cxx
index f7b1f27bb5e6..e74cc23d4749 100644..100755
--- a/cli_ure/source/climaker/climaker_app.cxx
+++ b/cli_ure/source/climaker/climaker_app.cxx
@@ -483,17 +483,15 @@ SAL_IMPLEMENT_MAIN()
                 Sequence< Any >( &arg, 1 ), xContext ) );
         // insert provider to tdmgr
         Reference< container::XSet > xSet( xTDmgr, UNO_QUERY_THROW );
-        Any provider( makeAny( xTD_provider ) );
-        xSet->insert( provider );
-        OSL_ASSERT( xSet->has( provider ) );
-        if (! extra_registries.empty())
+        for (vector< OUString >::iterator i(extra_registries.begin());
+             i != extra_registries.end(); ++i)
         {
-            arg = makeAny( open_registries( extra_registries, xContext ) );
-            provider = makeAny(
-                xTDprov_factory->createInstanceWithArgumentsAndContext(
-                    Sequence< Any >( &arg, 1 ), xContext ) );
-            xSet->insert( provider );
-            OSL_ASSERT( xSet->has( provider ) );
+            xSet->insert(makeAny(*i));
+        }
+        for (vector< OUString >::iterator i(mandatory_registries.begin());
+             i != mandatory_registries.end(); ++i)
+        {
+            xSet->insert(makeAny(*i));
         }
 
         if (0 == output.getLength()) // no output file specified
diff --git a/cppuhelper/Library_cppuhelper.mk b/cppuhelper/Library_cppuhelper.mk
index 577efbcf942d..b594b533aea1 100644
--- a/cppuhelper/Library_cppuhelper.mk
+++ b/cppuhelper/Library_cppuhelper.mk
@@ -75,7 +75,7 @@ $(eval $(call gb_Library_add_exception_objects,cppuhelper,\
 	cppuhelper/source/shlib \
 	cppuhelper/source/supportsservice \
 	cppuhelper/source/tdmgr \
-	cppuhelper/source/typedescriptionprovider \
+	cppuhelper/source/typemanager \
 	cppuhelper/source/typeprovider \
 	cppuhelper/source/unourl \
 	cppuhelper/source/weak \
diff --git a/cppuhelper/source/defaultbootstrap.cxx b/cppuhelper/source/defaultbootstrap.cxx
index 10c8eaf76450..fc790bac1134 100644
--- a/cppuhelper/source/defaultbootstrap.cxx
+++ b/cppuhelper/source/defaultbootstrap.cxx
@@ -12,8 +12,6 @@
 #include <cassert>
 #include <vector>
 
-#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
-#include "com/sun/star/container/XSet.hpp"
 #include "com/sun/star/uno/DeploymentException.hpp"
 #include "com/sun/star/uno/Any.hxx"
 #include "com/sun/star/uno/Reference.hxx"
@@ -29,7 +27,7 @@ using rtl::OUString;
 #include "macro_expander.hxx"
 #include "paths.hxx"
 #include "servicemanager.hxx"
-#include "typedescriptionprovider.hxx"
+#include "typemanager.hxx"
 
 namespace {
 
@@ -60,6 +58,9 @@ cppu::defaultBootstrap_InitialComponentContext(rtl::OUString const & iniUri)
     rtl::Reference< cppuhelper::ServiceManager > smgr(
         new cppuhelper::ServiceManager(
             getBootstrapVariable(bs, "UNO_SERVICES")));
+    rtl::Reference< cppuhelper::TypeManager > tmgr(
+        new cppuhelper::TypeManager(
+            getBootstrapVariable(bs, "UNO_TYPES")));
     cppu::ContextEntry_Init entry;
     std::vector< cppu::ContextEntry_Init > context_values;
     context_values.push_back(
@@ -69,6 +70,13 @@ cppu::defaultBootstrap_InitialComponentContext(rtl::OUString const & iniUri)
                 css::uno::Reference< css::uno::XInterface >(
                     static_cast< cppu::OWeakObject * >(smgr.get()))),
             false));
+    context_values.push_back(
+        cppu::ContextEntry_Init(
+            "/singletons/com.sun.star.reflection.theTypeDescriptionManager",
+            css::uno::makeAny(
+                css::uno::Reference< css::uno::XInterface >(
+                    static_cast< cppu::OWeakObject * >(tmgr.get()))),
+            false));
     context_values.push_back( //TODO: from services.rdb?
         cppu::ContextEntry_Init(
             "/singletons/com.sun.star.util.theMacroExpander",
@@ -92,18 +100,7 @@ cppu::defaultBootstrap_InitialComponentContext(rtl::OUString const & iniUri)
             &context_values[0], context_values.size(),
             css::uno::Reference< css::uno::XComponentContext >()));
     smgr->setContext(context);
-    css::uno::Reference< css::container::XHierarchicalNameAccess > tdmgr(
-        context->getValueByName(
-            "/singletons/com.sun.star.reflection.theTypeDescriptionManager"),
-        css::uno::UNO_QUERY_THROW);
-    css::uno::Reference< css::container::XSet >(
-        tdmgr, css::uno::UNO_QUERY_THROW)->
-        insert(
-            css::uno::makeAny(
-                cppuhelper::createTypeDescriptionProviders(
-                    getBootstrapVariable(bs, "UNO_TYPES"), smgr.get(),
-                    context)));
-    cppu::installTypeDescriptionManager(tdmgr);
+    cppu::installTypeDescriptionManager(tmgr.get());
     return context;
 }
 
diff --git a/cppuhelper/source/typedescriptionprovider.hxx b/cppuhelper/source/typedescriptionprovider.hxx
deleted file mode 100644
index 93336e8982f6..000000000000
--- a/cppuhelper/source/typedescriptionprovider.hxx
+++ /dev/null
@@ -1,39 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-
-#ifndef INCLUDED_CPPUHELPER_SOURCE_TYPEDESCRIPTIONPROVIDER_HXX
-#define INCLUDED_CPPUHELPER_SOURCE_TYPEDESCRIPTIONPROVIDER_HXX
-
-#include "sal/config.h"
-
-#include "com/sun/star/uno/Reference.hxx"
-#include "com/sun/star/uno/Sequence.hxx"
-
-namespace com { namespace sun { namespace star {
-     namespace container { class XHierarchicalNameAccess; }
-     namespace lang { class XMultiComponentFactory; }
-     namespace uno { class XComponentContext; }
-} } }
-namespace rtl { class OUString; }
-
-namespace cppuhelper {
-
-css::uno::Sequence<
-    css::uno::Reference< css::container::XHierarchicalNameAccess > >
-createTypeDescriptionProviders(
-    rtl::OUString const & uris,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context);
-
-}
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppuhelper/source/typedescriptionprovider.cxx b/cppuhelper/source/typemanager.cxx
index b87575da242b..4185ddc976b6 100644
--- a/cppuhelper/source/typedescriptionprovider.cxx
+++ b/cppuhelper/source/typemanager.cxx
@@ -10,16 +10,17 @@
 #include "sal/config.h"
 
 #include <cassert>
+#include <cstddef>
 #include <cstdlib>
+#include <cstring>
 #include <set>
 #include <stack>
 #include <vector>
 
 #include "boost/noncopyable.hpp"
+#include "com/sun/star/container/ElementExistException.hpp"
 #include "com/sun/star/container/NoSuchElementException.hpp"
-#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
-#include "com/sun/star/lang/XInitialization.hpp"
-#include "com/sun/star/lang/XMultiComponentFactory.hpp"
+#include "com/sun/star/lang/IllegalArgumentException.hpp"
 #include "com/sun/star/reflection/InvalidTypeNameException.hpp"
 #include "com/sun/star/reflection/NoSuchTypeNameException.hpp"
 #include "com/sun/star/reflection/TypeDescriptionSearchDepth.hpp"
@@ -35,61 +36,99 @@
 #include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
 #include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
 #include "com/sun/star/reflection/XStructTypeDescription.hpp"
-#include "com/sun/star/reflection/XTypeDescriptionEnumeration.hpp"
-#include "com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp"
-#include "com/sun/star/registry/InvalidRegistryException.hpp"
-#include "com/sun/star/registry/XSimpleRegistry.hpp"
+#include "com/sun/star/reflection/XTypeDescription.hpp"
 #include "com/sun/star/uno/Any.hxx"
 #include "com/sun/star/uno/DeploymentException.hpp"
 #include "com/sun/star/uno/Reference.hxx"
 #include "com/sun/star/uno/RuntimeException.hpp"
 #include "com/sun/star/uno/Sequence.hxx"
+#include "com/sun/star/uno/Type.hxx"
 #include "com/sun/star/uno/TypeClass.hpp"
-#include "com/sun/star/uno/XComponentContext.hpp"
-#include "com/sun/star/uno/XInterface.hpp"
-#include "cppuhelper/compbase2.hxx"
+#include "cppu/unotype.hxx"
 #include "cppuhelper/implbase1.hxx"
+#include "cppuhelper/supportsservice.hxx"
 #include "osl/file.hxx"
 #include "osl/mutex.hxx"
 #include "rtl/ref.hxx"
+#include "rtl/string.h"
 #include "rtl/ustring.hxx"
+#include "sal/macros.h"
 #include "sal/types.h"
 
 using rtl::OUString;
 
 #include "unoidl/unoidl.hxx"
-#include "unoidl/unoidlprovider.hxx"
 
 #include "paths.hxx"
-#include "typedescriptionprovider.hxx"
+#include "typemanager.hxx"
 
 namespace {
 
-css::uno::Reference< css::reflection::XTypeDescription > resolve(
-    css::uno::Reference< css::uno::XComponentContext > const & context,
-    rtl::OUString const & name)
-{
-    assert(context.is());
-    try {
-        return css::uno::Reference< css::reflection::XTypeDescription >(
-            (css::uno::Reference< css::container::XHierarchicalNameAccess >(
-                context->getValueByName(
-                    "/singletons/"
-                    "com.sun.star.reflection.theTypeDescriptionManager"),
-                css::uno::UNO_QUERY_THROW)->
-             getByHierarchicalName(name)),
-            css::uno::UNO_QUERY_THROW);
-    } catch (css::container::NoSuchElementException & e) {
-        throw css::uno::DeploymentException(
-            ("cannot resolve type \"" + name + "\"; NoSuchElementException: "
-             + e.Message),
-            e.Context);
+css::uno::Any resolveTypedefs(css::uno::Any const & type) {
+    for (css::uno::Any t(type);;) {
+        css::uno::Reference< css::reflection::XIndirectTypeDescription > ind(
+            type, css::uno::UNO_QUERY);
+        if (!ind.is() || ind->getTypeClass() != css::uno::TypeClass_TYPEDEF) {
+            return t;
+        }
+        t = css::uno::makeAny(ind->getReferencedType());
     }
 }
 
+class SimpleTypeDescription:
+    public cppu::WeakImplHelper1< css::reflection::XTypeDescription >
+{
+public:
+    SimpleTypeDescription(
+        css::uno::TypeClass typeClass, rtl::OUString const & name):
+        typeClass_(typeClass), name_(name)
+    {}
+
+private:
+    virtual ~SimpleTypeDescription() {}
+
+    virtual css::uno::TypeClass SAL_CALL getTypeClass()
+        throw (css::uno::RuntimeException)
+    { return typeClass_; }
+
+    virtual rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException)
+    { return name_; }
+
+    css::uno::TypeClass typeClass_;
+    rtl::OUString name_;
+};
+
+class SequenceTypeDescription:
+    public cppu::WeakImplHelper1< css::reflection::XIndirectTypeDescription >
+{
+public:
+    SequenceTypeDescription(
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
+        rtl::OUString const & name, rtl::OUString const & componentType):
+        manager_(manager), name_(name), componentType_(componentType)
+    { assert(manager.is()); }
+
+private:
+    virtual ~SequenceTypeDescription() {}
+
+    virtual css::uno::TypeClass SAL_CALL getTypeClass()
+        throw (css::uno::RuntimeException)
+    { return css::uno::TypeClass_SEQUENCE; }
+
+    virtual rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException)
+    { return name_; }
+
+    virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
+    getReferencedType() throw (css::uno::RuntimeException)
+    { return manager_->resolve(componentType_); }
+
+    rtl::Reference< cppuhelper::TypeManager > manager_;
+    rtl::OUString name_;
+    rtl::OUString componentType_;
+};
+
 class PublishableDescription:
-    public cppu::WeakImplHelper1< css::reflection::XPublished >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XPublished >
 {
 protected:
     PublishableDescription(bool published): published_(published) {}
@@ -104,16 +143,15 @@ private:
 };
 
 class ModuleDescription:
-    public cppu::WeakImplHelper1< css::reflection::XModuleTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XModuleTypeDescription >
 {
 public:
     ModuleDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ModuleEntity > const & entity):
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~ModuleDescription() {}
@@ -130,7 +168,7 @@ private:
         css::uno::Reference< css::reflection::XTypeDescription > >
     SAL_CALL getMembers() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ModuleEntity > entity_;
 };
@@ -144,7 +182,7 @@ ModuleDescription::getMembers() throw (css::uno::RuntimeException) {
         css::uno::Sequence<
             css::uno::Reference< css::reflection::XTypeDescription > > s(n);
         for (sal_Int32 i = 0; i != n; ++i) {
-            s[i] = resolve(context_, name_ + "." + names[i]);
+            s[i] = manager_->resolve(name_ + "." + names[i]);
         }
         return s;
     } catch (unoidl::FileFormatException & e) {
@@ -222,12 +260,12 @@ PlainStructTypeDescription_Base;
 class PlainStructTypeDescription: public PlainStructTypeDescription_Base {
 public:
     PlainStructTypeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::PlainStructTypeEntity > const & entity):
         PlainStructTypeDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~PlainStructTypeDescription() {}
@@ -243,7 +281,7 @@ private:
     getBaseType() throw (css::uno::RuntimeException) {
         return entity_->getDirectBase().isEmpty()
             ? css::uno::Reference< css::reflection::XTypeDescription >()
-            : resolve(context_, entity_->getDirectBase());
+            : manager_->resolve(entity_->getDirectBase());
     }
 
     virtual
@@ -266,7 +304,7 @@ private:
             css::uno::Reference< css::reflection::XTypeDescription > >();
     }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::PlainStructTypeEntity > entity_;
 };
@@ -279,7 +317,7 @@ PlainStructTypeDescription::getMemberTypes() throw (css::uno::RuntimeException)
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectMembers()[i].type);
+        s[i] = manager_->resolve(entity_->getDirectMembers()[i].type);
     }
     return s;
 }
@@ -297,8 +335,7 @@ css::uno::Sequence< rtl::OUString > PlainStructTypeDescription::getMemberNames()
 }
 
 class ParameterizedMemberTypeDescription:
-    public cppu::WeakImplHelper1< css::reflection::XTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XTypeDescription >
 {
 public:
     explicit ParameterizedMemberTypeDescription(
@@ -328,13 +365,13 @@ class PolymorphicStructTypeTemplateDescription:
 {
 public:
     PolymorphicStructTypeTemplateDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
             entity):
         PolymorphicStructTypeTemplateDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~PolymorphicStructTypeTemplateDescription() {}
@@ -369,7 +406,7 @@ private:
             css::uno::Reference< css::reflection::XTypeDescription > >();
     }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
 };
@@ -386,7 +423,7 @@ PolymorphicStructTypeTemplateDescription::getMemberTypes()
         s[i] = entity_->getMembers()[i].parameterized
             ? new ParameterizedMemberTypeDescription(
                 entity_->getMembers()[i].type)
-            : resolve(context_, entity_->getMembers()[i].type);
+            : manager_->resolve(entity_->getMembers()[i].type);
     }
     return s;
 }
@@ -417,6 +454,114 @@ PolymorphicStructTypeTemplateDescription::getTypeParameters()
     return s;
 }
 
+class InstantiatedPolymorphicStructTypeDescription:
+    public cppu::WeakImplHelper1< css::reflection::XStructTypeDescription >
+{
+public:
+    InstantiatedPolymorphicStructTypeDescription(
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
+        rtl::OUString const & name,
+        rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
+            entity,
+        std::vector< rtl::OUString > const & arguments):
+        manager_(manager), name_(name), entity_(entity), arguments_(arguments)
+    {
+        assert(manager.is());
+        assert(entity.is());
+        assert(arguments.size() == entity->getTypeParameters().size());
+    }
+
+private:
+    virtual ~InstantiatedPolymorphicStructTypeDescription() {}
+
+    virtual css::uno::TypeClass SAL_CALL getTypeClass()
+        throw (css::uno::RuntimeException)
+    { return css::uno::TypeClass_STRUCT; }
+
+    virtual rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException)
+    { return name_; }
+
+    virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
+    getBaseType() throw (css::uno::RuntimeException)
+    { return css::uno::Reference< css::reflection::XTypeDescription >(); }
+
+    virtual
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > >
+    SAL_CALL getMemberTypes() throw (css::uno::RuntimeException);
+
+    virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames()
+        throw (css::uno::RuntimeException);
+
+    virtual css::uno::Sequence< rtl::OUString > SAL_CALL getTypeParameters()
+        throw (css::uno::RuntimeException)
+    { return css::uno::Sequence< rtl::OUString >(); }
+
+    virtual
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > >
+    SAL_CALL getTypeArguments() throw (css::uno::RuntimeException);
+
+    rtl::Reference< cppuhelper::TypeManager > manager_;
+    rtl::OUString name_;
+    rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
+    std::vector< rtl::OUString > arguments_;
+};
+
+css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
+InstantiatedPolymorphicStructTypeDescription::getMemberTypes()
+    throw (css::uno::RuntimeException)
+{
+    assert(entity_->getMembers().size() <= SAL_MAX_INT32);
+    sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > > s(n);
+    for (sal_Int32 i = 0; i != n; ++i) {
+        rtl::OUString type(entity_->getMembers()[i].type);
+        if (entity_->getMembers()[i].parameterized) {
+            for (std::vector< rtl::OUString >::const_iterator j(
+                     entity_->getTypeParameters().begin());
+                 j != entity_->getTypeParameters().end(); ++j)
+            {
+                if (*j == type) {
+                    type = arguments_[j - entity_->getTypeParameters().begin()];
+                    goto found;
+                }
+            }
+            assert(false); // this cannot happen                         //TODO!
+        found:;
+        }
+        s[i] = manager_->resolve(type);
+    }
+    return s;
+}
+
+css::uno::Sequence< rtl::OUString >
+InstantiatedPolymorphicStructTypeDescription::getMemberNames()
+    throw (css::uno::RuntimeException)
+{
+    assert(entity_->getMembers().size() <= SAL_MAX_INT32);
+    sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
+    css::uno::Sequence< rtl::OUString > s(n);
+    for (sal_Int32 i = 0; i != n; ++i) {
+        s[i] = entity_->getMembers()[i].name;
+    }
+    return s;
+}
+css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
+InstantiatedPolymorphicStructTypeDescription::getTypeArguments()
+    throw (css::uno::RuntimeException)
+{
+    assert(arguments_.size() <= SAL_MAX_INT32);
+    sal_Int32 n = static_cast< sal_Int32 >(arguments_.size());
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > > s(n);
+    for (sal_Int32 i = 0; i != n; ++i) {
+        s[i] = manager_->resolve(arguments_[i]);
+    }
+    return s;
+}
+
 typedef cppu::ImplInheritanceHelper1<
     PublishableDescription, css::reflection::XCompoundTypeDescription >
 ExceptionTypeDescription_Base;
@@ -424,12 +569,12 @@ ExceptionTypeDescription_Base;
 class ExceptionTypeDescription: public ExceptionTypeDescription_Base {
 public:
     ExceptionTypeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ExceptionTypeEntity > const & entity):
-        ExceptionTypeDescription_Base(entity->isPublished()), context_(context),
+        ExceptionTypeDescription_Base(entity->isPublished()), manager_(manager),
         name_(name), entity_(entity)
-    { assert(entity.is()); }
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~ExceptionTypeDescription() {}
@@ -445,7 +590,7 @@ private:
     getBaseType() throw (css::uno::RuntimeException) {
         return entity_->getDirectBase().isEmpty()
             ? css::uno::Reference< css::reflection::XTypeDescription >()
-            : resolve(context_, entity_->getDirectBase());
+            : manager_->resolve(entity_->getDirectBase());
     }
 
     virtual
@@ -456,7 +601,7 @@ private:
     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames()
         throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ExceptionTypeEntity > entity_;
 };
@@ -468,7 +613,7 @@ ExceptionTypeDescription::getMemberTypes() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectMembers()[i].type);
+        s[i] = manager_->resolve(entity_->getDirectMembers()[i].type);
     }
     return s;
 }
@@ -485,86 +630,19 @@ css::uno::Sequence< rtl::OUString > ExceptionTypeDescription::getMemberNames()
     return s;
 }
 
-css::uno::Reference< css::reflection::XTypeDescription > resolveTypedefs(
-    css::uno::Reference< css::reflection::XTypeDescription > const & type)
-{
-    css::uno::Reference< css::reflection::XTypeDescription > resolved(type);
-    while (resolved->getTypeClass() == css::uno::TypeClass_TYPEDEF) {
-        resolved
-            = (css::uno::Reference< css::reflection::XIndirectTypeDescription >(
-                   resolved, css::uno::UNO_QUERY_THROW)->
-               getReferencedType());
-    }
-    return resolved;
-}
-
-class BaseOffset: private boost::noncopyable {
-public:
-    BaseOffset(
-        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
-            const & description);
-
-    sal_Int32 get() const { return offset_; }
-
-private:
-    void calculateBases(
-        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
-            const & description);
-
-    void calculate(
-        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
-            const & description);
-
-    std::set< rtl::OUString > set_;
-    sal_Int32 offset_;
-};
-
-BaseOffset::BaseOffset(
-    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
-        description):
-    offset_(0)
-{
-    calculateBases(description);
-}
-
-void BaseOffset::calculateBases(
-    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
-        description)
-{
-    css::uno::Sequence<
-        css::uno::Reference < css::reflection::XTypeDescription > > bases(
-            description->getBaseTypes());
-    for (sal_Int32 i = 0; i != bases.getLength(); ++i) {
-        calculate(
-            css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
-                resolveTypedefs(bases[i]), css::uno::UNO_QUERY_THROW));
-    }
-}
-
-void BaseOffset::calculate(
-    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
-        description)
-{
-    if (set_.insert(description->getName()).second) {
-        calculateBases(description);
-        offset_ += description->getMembers().getLength();
-    }
-}
-
 class AttributeDescription:
     public cppu::WeakImplHelper1<
-        css::reflection::XInterfaceAttributeTypeDescription2 >,
-    private boost::noncopyable
+        css::reflection::XInterfaceAttributeTypeDescription2 >
 {
 public:
     AttributeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         unoidl::InterfaceTypeEntity::Attribute const & attribute,
         sal_Int32 position):
-        context_(context), name_(name), attribute_(attribute),
+        manager_(manager), name_(name), attribute_(attribute),
         position_(position)
-    {}
+    { assert(manager.is()); }
 
 private:
     virtual ~AttributeDescription() {}
@@ -588,7 +666,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getType() throw (css::uno::RuntimeException)
-    { return resolve(context_, attribute_.type); }
+    { return manager_->resolve(attribute_.type); }
 
     virtual sal_Bool SAL_CALL isBound() throw (css::uno::RuntimeException)
     { return attribute_.bound; }
@@ -603,7 +681,7 @@ private:
         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
     SAL_CALL getSetExceptions() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     unoidl::InterfaceTypeEntity::Attribute attribute_;
     sal_Int32 position_;
@@ -618,7 +696,7 @@ AttributeDescription::getGetExceptions() throw (css::uno::RuntimeException) {
         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, attribute_.getExceptions[i]),
+            manager_->resolve(attribute_.getExceptions[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -633,23 +711,22 @@ AttributeDescription::getSetExceptions() throw (css::uno::RuntimeException) {
         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, attribute_.setExceptions[i]),
+            manager_->resolve(attribute_.setExceptions[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
 }
 
 class MethodParameter:
-    public cppu::WeakImplHelper1< css::reflection::XMethodParameter >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XMethodParameter >
 {
 public:
     MethodParameter(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::InterfaceTypeEntity::Method::Parameter const & parameter,
         sal_Int32 position):
-        context_(context), parameter_(parameter), position_(position)
-    {}
+        manager_(manager), parameter_(parameter), position_(position)
+    { assert(manager.is()); }
 
 private:
     virtual ~MethodParameter() {}
@@ -659,7 +736,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getType() throw (css::uno::RuntimeException)
-    { return resolve(context_, parameter_.type); }
+    { return manager_->resolve(parameter_.type); }
 
     virtual sal_Bool SAL_CALL isIn() throw (css::uno::RuntimeException) {
         return
@@ -682,23 +759,22 @@ private:
     virtual sal_Int32 SAL_CALL getPosition() throw (css::uno::RuntimeException)
     { return position_; }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::InterfaceTypeEntity::Method::Parameter parameter_;
     sal_Int32 position_;
 };
 
 class MethodDescription:
     public cppu::WeakImplHelper1<
-        css::reflection::XInterfaceMethodTypeDescription >,
-    private boost::noncopyable
+        css::reflection::XInterfaceMethodTypeDescription >
 {
 public:
     MethodDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         unoidl::InterfaceTypeEntity::Method const & method, sal_Int32 position):
-        context_(context), name_(name), method_(method), position_(position)
-    {}
+        manager_(manager), name_(name), method_(method), position_(position)
+    { assert(manager.is()); }
 
 private:
     virtual ~MethodDescription() {}
@@ -719,7 +795,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getReturnType() throw (css::uno::RuntimeException)
-    { return resolve(context_, method_.returnType); }
+    { return manager_->resolve(method_.returnType); }
 
     virtual sal_Bool SAL_CALL isOneway() throw (css::uno::RuntimeException)
     { return false; }
@@ -734,7 +810,7 @@ private:
         css::uno::Reference< css::reflection::XTypeDescription > >
     SAL_CALL getExceptions() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     unoidl::InterfaceTypeEntity::Method method_;
     sal_Int32 position_;
@@ -747,7 +823,7 @@ MethodDescription::getParameters() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XMethodParameter > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = new MethodParameter(context_, method_.parameters[i], i);
+        s[i] = new MethodParameter(manager_, method_.parameters[i], i);
     }
     return s;
 }
@@ -759,11 +835,65 @@ MethodDescription::getExceptions() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, method_.exceptions[i]);
+        s[i] = manager_->resolve(method_.exceptions[i]);
     }
     return s;
 }
 
+class BaseOffset: private boost::noncopyable {
+public:
+    BaseOffset(
+        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
+            const & description);
+
+    sal_Int32 get() const { return offset_; }
+
+private:
+    void calculateBases(
+        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
+            const & description);
+
+    void calculate(
+        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
+            const & description);
+
+    std::set< rtl::OUString > set_;
+    sal_Int32 offset_;
+};
+
+BaseOffset::BaseOffset(
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
+        description):
+    offset_(0)
+{
+    calculateBases(description);
+}
+
+void BaseOffset::calculateBases(
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
+        description)
+{
+    css::uno::Sequence<
+        css::uno::Reference < css::reflection::XTypeDescription > > bases(
+            description->getBaseTypes());
+    for (sal_Int32 i = 0; i != bases.getLength(); ++i) {
+        calculate(
+            css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
+                resolveTypedefs(css::uno::makeAny(bases[i])),
+                css::uno::UNO_QUERY_THROW));
+    }
+}
+
+void BaseOffset::calculate(
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
+        description)
+{
+    if (set_.insert(description->getName()).second) {
+        calculateBases(description);
+        offset_ += description->getMembers().getLength();
+    }
+}
+
 typedef cppu::ImplInheritanceHelper1<
     PublishableDescription, css::reflection::XInterfaceTypeDescription2 >
 InterfaceTypeDescription_Base;
@@ -771,12 +901,12 @@ InterfaceTypeDescription_Base;
 class InterfaceTypeDescription: public InterfaceTypeDescription_Base {
 public:
     InterfaceTypeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::InterfaceTypeEntity > const & entity):
-        InterfaceTypeDescription_Base(entity->isPublished()), context_(context),
+        InterfaceTypeDescription_Base(entity->isPublished()), manager_(manager),
         name_(name), entity_(entity)
-    { assert(entity.is()); }
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~InterfaceTypeDescription() {}
@@ -792,7 +922,7 @@ private:
     getBaseType() throw (css::uno::RuntimeException) {
         return entity_->getDirectMandatoryBases().empty()
             ? css::uno::Reference< css::reflection::XTypeDescription >()
-            : resolve(context_, entity_->getDirectMandatoryBases()[0]);
+            : manager_->resolve(entity_->getDirectMandatoryBases()[0]);
     }
 
     virtual css::uno::Uik SAL_CALL getUik() throw (css::uno::RuntimeException)
@@ -814,7 +944,7 @@ private:
         css::uno::Reference< css::reflection::XTypeDescription > >
     SAL_CALL getOptionalBaseTypes() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::InterfaceTypeEntity > entity_;
 };
@@ -835,12 +965,12 @@ InterfaceTypeDescription::getMembers() throw (css::uno::RuntimeException) {
     sal_Int32 off = BaseOffset(this).get();
     for (sal_Int32 i = 0; i != n1; ++i) {
         s[i] = new AttributeDescription(
-            context_, name_ + "::" + entity_->getDirectAttributes()[i].name,
+            manager_, name_ + "::" + entity_->getDirectAttributes()[i].name,
             entity_->getDirectAttributes()[i], off + i);
     }
     for (sal_Int32 i = 0; i != n2; ++i) {
         s[n1 + i] = new MethodDescription(
-            context_, name_ + "::" + entity_->getDirectMethods()[i].name,
+            manager_, name_ + "::" + entity_->getDirectMethods()[i].name,
             entity_->getDirectMethods()[i], off + n1 + i);
     }
     return s;
@@ -854,7 +984,7 @@ InterfaceTypeDescription::getBaseTypes() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectMandatoryBases()[i]);
+        s[i] = manager_->resolve(entity_->getDirectMandatoryBases()[i]);
     }
     return s;
 }
@@ -869,20 +999,17 @@ InterfaceTypeDescription::getOptionalBaseTypes()
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectOptionalBases()[i]);
+        s[i] = manager_->resolve(entity_->getDirectOptionalBases()[i]);
     }
     return s;
 }
 
 class ConstantDescription:
-    public cppu::WeakImplHelper1< css::reflection::XConstantTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XConstantTypeDescription >
 {
 public:
-    ConstantDescription(
-        rtl::OUString const & name, css::uno::Any const & value):
-        name_(name), value_(value)
-    {}
+    explicit ConstantDescription(
+        unoidl::ConstantGroupEntity::Member const & member);
 
 private:
     virtual ~ConstantDescription() {}
@@ -902,6 +1029,46 @@ private:
     css::uno::Any value_;
 };
 
+ConstantDescription::ConstantDescription(
+    unoidl::ConstantGroupEntity::Member const & member):
+    name_(member.name)
+{
+    switch (member.value.type) {
+    case unoidl::ConstantValue::TYPE_BOOLEAN:
+        value_ <<= member.value.booleanValue;
+        break;
+    case unoidl::ConstantValue::TYPE_BYTE:
+        value_ <<= member.value.byteValue;
+        break;
+    case unoidl::ConstantValue::TYPE_SHORT:
+        value_ <<= member.value.shortValue;
+        break;
+    case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
+        value_ <<= member.value.unsignedShortValue;
+        break;
+    case unoidl::ConstantValue::TYPE_LONG:
+        value_ <<= member.value.longValue;
+        break;
+    case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
+        value_ <<= member.value.unsignedLongValue;
+        break;
+    case unoidl::ConstantValue::TYPE_HYPER:
+        value_ <<= member.value.hyperValue;
+        break;
+    case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
+        value_ <<= member.value.unsignedHyperValue;
+        break;
+    case unoidl::ConstantValue::TYPE_FLOAT:
+        value_ <<= member.value.floatValue;
+        break;
+    case unoidl::ConstantValue::TYPE_DOUBLE:
+        value_ <<= member.value.doubleValue;
+        break;
+    default:
+        for (;;) { std::abort(); } // this cannot happen
+    }
+}
+
 typedef cppu::ImplInheritanceHelper1<
     PublishableDescription, css::reflection::XConstantsTypeDescription >
 ConstantGroupDescription_Base;
@@ -909,11 +1076,10 @@ ConstantGroupDescription_Base;
 class ConstantGroupDescription: public ConstantGroupDescription_Base {
 public:
     ConstantGroupDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ConstantGroupEntity > const & entity):
-        ConstantGroupDescription_Base(entity->isPublished()), context_(context),
-        name_(name), entity_(entity)
+        ConstantGroupDescription_Base(entity->isPublished()), name_(name),
+        entity_(entity)
     { assert(entity.is()); }
 
 private:
@@ -931,7 +1097,6 @@ private:
         css::uno::Reference< css::reflection::XConstantTypeDescription > >
     SAL_CALL getConstants() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ConstantGroupEntity > entity_;
 };
@@ -944,10 +1109,7 @@ ConstantGroupDescription::getConstants() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XConstantTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        //TODO: use entity_->getMembers()[i].value directly?
-        s[i].set(
-            resolve(context_, name_ + "." + entity_->getMembers()[i].name),
-            css::uno::UNO_QUERY_THROW);
+        s[i] = new ConstantDescription(entity_->getMembers()[i]);
     }
     return s;
 }
@@ -959,12 +1121,12 @@ TypedefDescription_Base;
 class TypedefDescription: public TypedefDescription_Base {
 public:
     TypedefDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::TypedefEntity > const & entity):
-        TypedefDescription_Base(entity->isPublished()), context_(context),
+        TypedefDescription_Base(entity->isPublished()), manager_(manager),
         name_(name), entity_(entity)
-    { assert(entity.is()); }
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~TypedefDescription() {}
@@ -978,25 +1140,24 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getReferencedType() throw (css::uno::RuntimeException)
-    { return resolve(context_, entity_->getType()); }
+    { return manager_->resolve(entity_->getType()); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::TypedefEntity > entity_;
 };
 
 class ConstructorParameter:
-    public cppu::WeakImplHelper1< css::reflection::XParameter >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XParameter >
 {
 public:
     ConstructorParameter(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
             const & parameter,
         sal_Int32 position):
-        context_(context), parameter_(parameter), position_(position)
-    {}
+        manager_(manager), parameter_(parameter), position_(position)
+    { assert(manager.is()); }
 
 private:
     virtual ~ConstructorParameter() {}
@@ -1006,7 +1167,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getType() throw (css::uno::RuntimeException)
-    { return resolve(context_, parameter_.type); }
+    { return manager_->resolve(parameter_.type); }
 
     virtual sal_Bool SAL_CALL isIn() throw (css::uno::RuntimeException)
     { return true; }
@@ -1021,7 +1182,7 @@ private:
         throw (css::uno::RuntimeException)
     { return parameter_.rest; }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
         parameter_;
     sal_Int32 position_;
@@ -1029,16 +1190,15 @@ private:
 
 class ConstructorDescription:
     public cppu::WeakImplHelper1<
-        css::reflection::XServiceConstructorDescription >,
-    private boost::noncopyable
+        css::reflection::XServiceConstructorDescription >
 {
 public:
     ConstructorDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::SingleInterfaceBasedServiceEntity::Constructor const &
             constructor):
-        context_(context), constructor_(constructor)
-    {}
+        manager_(manager), constructor_(constructor)
+    { assert(manager.is()); }
 
 private:
     virtual ~ConstructorDescription() {}
@@ -1060,7 +1220,7 @@ private:
         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
     SAL_CALL getExceptions() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::SingleInterfaceBasedServiceEntity::Constructor constructor_;
 };
 
@@ -1072,7 +1232,7 @@ ConstructorDescription::getParameters() throw (css::uno::RuntimeException) {
         n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i] = new ConstructorParameter(
-            context_, constructor_.parameters[i], i);
+            manager_, constructor_.parameters[i], i);
     }
     return s;
 }
@@ -1086,7 +1246,7 @@ ConstructorDescription::getExceptions() throw (css::uno::RuntimeException) {
         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, constructor_.exceptions[i]),
+            manager_->resolve(constructor_.exceptions[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1101,13 +1261,13 @@ class SingleInterfaceBasedServiceDescription:
 {
 public:
     SingleInterfaceBasedServiceDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > const &
             entity):
         SingleInterfaceBasedServiceDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~SingleInterfaceBasedServiceDescription() {}
@@ -1173,14 +1333,14 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getInterface() throw (css::uno::RuntimeException)
-    { return resolve(context_, entity_->getBase()); }
+    { return manager_->resolve(entity_->getBase()); }
 
     virtual
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XServiceConstructorDescription > >
     SAL_CALL getConstructors() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > entity_;
 };
@@ -1197,21 +1357,20 @@ SingleInterfaceBasedServiceDescription::getConstructors()
             s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i] = new ConstructorDescription(
-            context_, entity_->getConstructors()[i]);
+            manager_, entity_->getConstructors()[i]);
     }
     return s;
 }
 
 class PropertyDescription:
-    public cppu::WeakImplHelper1< css::reflection::XPropertyTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XPropertyTypeDescription >
 {
 public:
     PropertyDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::AccumulationBasedServiceEntity::Property const & property):
-        context_(context), property_(property)
-    {}
+        manager_(manager), property_(property)
+    { assert(manager.is()); }
 
 private:
     virtual ~PropertyDescription() {}
@@ -1229,9 +1388,9 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getPropertyTypeDescription() throw (css::uno::RuntimeException)
-    { return resolve(context_, property_.type); }
+    { return manager_->resolve(property_.type); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::AccumulationBasedServiceEntity::Property property_;
 };
 
@@ -1244,13 +1403,13 @@ class AccumulationBasedServiceDescription:
 {
 public:
     AccumulationBasedServiceDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::AccumulationBasedServiceEntity > const &
             entity):
         AccumulationBasedServiceDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~AccumulationBasedServiceDescription() {}
@@ -1305,7 +1464,7 @@ private:
                 css::reflection::XServiceConstructorDescription > >();
     }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::AccumulationBasedServiceEntity > entity_;
 };
@@ -1322,7 +1481,7 @@ AccumulationBasedServiceDescription::getMandatoryServices()
         css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, entity_->getDirectMandatoryBaseServices()[i]),
+            manager_->resolve(entity_->getDirectMandatoryBaseServices()[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1340,7 +1499,7 @@ AccumulationBasedServiceDescription::getOptionalServices()
         css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, entity_->getDirectOptionalBaseServices()[i]),
+            manager_->resolve(entity_->getDirectOptionalBaseServices()[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1360,8 +1519,8 @@ AccumulationBasedServiceDescription::getMandatoryInterfaces()
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
             resolveTypedefs(
-                resolve(
-                    context_, entity_->getDirectMandatoryBaseInterfaces()[i])),
+                manager_->find(
+                    entity_->getDirectMandatoryBaseInterfaces()[i])),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1381,8 +1540,8 @@ AccumulationBasedServiceDescription::getOptionalInterfaces()
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
             resolveTypedefs(
-                resolve(
-                    context_, entity_->getDirectOptionalBaseInterfaces()[i])),
+                manager_->find(
+                    entity_->getDirectOptionalBaseInterfaces()[i])),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1400,7 +1559,7 @@ AccumulationBasedServiceDescription::getProperties()
         css::uno::Reference< css::reflection::XPropertyTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i] = new PropertyDescription(
-            context_, entity_->getDirectProperties()[i]);
+            manager_, entity_->getDirectProperties()[i]);
     }
     return s;
 }
@@ -1414,12 +1573,12 @@ class InterfaceBasedSingletonDescription:
 {
 public:
     InterfaceBasedSingletonDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::InterfaceBasedSingletonEntity > const & entity):
         InterfaceBasedSingletonDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~InterfaceBasedSingletonDescription() {}
@@ -1444,9 +1603,9 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription >
     SAL_CALL getInterface() throw (css::uno::RuntimeException)
-    { return resolve(context_, entity_->getBase()); }
+    { return manager_->resolve(entity_->getBase()); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::InterfaceBasedSingletonEntity > entity_;
 };
@@ -1460,12 +1619,12 @@ class ServiceBasedSingletonDescription:
 {
 public:
     ServiceBasedSingletonDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ServiceBasedSingletonEntity > const & entity):
         ServiceBasedSingletonDescription_Base(entity_->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~ServiceBasedSingletonDescription() {}
@@ -1481,7 +1640,7 @@ private:
     SAL_CALL getService() throw (css::uno::RuntimeException)
     {
         return css::uno::Reference< css::reflection::XServiceTypeDescription >(
-            resolve(context_, entity_->getBase()), css::uno::UNO_QUERY_THROW);
+            manager_->resolve(entity_->getBase()), css::uno::UNO_QUERY_THROW);
     }
 
     virtual sal_Bool SAL_CALL isInterfaceBased()
@@ -1492,24 +1651,23 @@ private:
     SAL_CALL getInterface() throw (css::uno::RuntimeException)
     { return css::uno::Reference< css::reflection::XTypeDescription >(); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ServiceBasedSingletonEntity > entity_;
 };
 
 class Enumeration:
-    public cppu::WeakImplHelper1<
-        css::reflection::XTypeDescriptionEnumeration >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XTypeDescriptionEnumeration >
 {
 public:
     Enumeration(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & prefix,
         rtl::Reference< unoidl::MapCursor > const & cursor,
         css::uno::Sequence< css::uno::TypeClass > const & types, bool deep):
-        context_(context), types_(types), deep_(deep)
+        manager_(manager), types_(types), deep_(deep)
     {
+        assert(manager.is());
         positions_.push(Position(prefix, cursor));
         findNextMatch();
     }
@@ -1558,7 +1716,7 @@ private:
             constantGroupIndex;
     };
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     css::uno::Sequence< css::uno::TypeClass > types_;
     bool deep_;
 
@@ -1582,7 +1740,7 @@ Enumeration::nextTypeDescription()
         name = current_;
         findNextMatch();
     }
-    return resolve(context_, name);
+    return manager_->resolve(name);
 }
 
 bool Enumeration::matches(css::uno::TypeClass tc) const {
@@ -1688,324 +1846,259 @@ void Enumeration::findNextMatch() {
     }
 }
 
-typedef cppu::WeakComponentImplHelper2<
-    css::container::XHierarchicalNameAccess,
-    css::reflection::XTypeDescriptionEnumerationAccess >
-Provider_Base;
+}
 
-class Provider:
-    private osl::Mutex, public Provider_Base, private boost::noncopyable
+cppuhelper::TypeManager::TypeManager(rtl::OUString const & rdbUris):
+    TypeManager_Base(*static_cast< osl::Mutex * >(this)),
+    manager_(new unoidl::Manager)
 {
-public:
-    // throws unoidl::FileFormatException, unoidl::NoSuchFileException:
-    Provider(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
-        rtl::OUString const & uri):
-        Provider_Base(*static_cast< osl::Mutex * >(this)), context_(context),
-        provider_(new unoidl::UnoidlProvider(uri))
-    {}
-
-    using Provider_Base::acquire;
-    using Provider_Base::release;
-
-private:
-    virtual ~Provider() {}
-
-    virtual void SAL_CALL disposing() {} //TODO
-
-    virtual css::uno::Any SAL_CALL getByHierarchicalName(
-        rtl::OUString const & aName)
-        throw (
-            css::container::NoSuchElementException, css::uno::RuntimeException);
-
-    virtual sal_Bool SAL_CALL hasByHierarchicalName(
-        rtl::OUString const & aName) throw (css::uno::RuntimeException);
-
-    virtual css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
-    SAL_CALL createTypeDescriptionEnumeration(
-        rtl::OUString const & moduleName,
-        css::uno::Sequence< css::uno::TypeClass > const & types,
-        css::reflection::TypeDescriptionSearchDepth depth)
-        throw(
-            css::reflection::NoSuchTypeNameException,
-            css::reflection::InvalidTypeNameException,
-            css::uno::RuntimeException);
-
-    css::uno::Reference< css::uno::XComponentContext > context_;
-    rtl::Reference< unoidl::UnoidlProvider > provider_;
-};
+    readRdbs(rdbUris);
+}
 
-css::uno::Any Provider::getByHierarchicalName(rtl::OUString const & aName)
-    throw (css::container::NoSuchElementException, css::uno::RuntimeException)
-{
-    try {
-        bool cnst;
-        sal_uInt32 off = provider_->find(aName, &cnst);
-        if (off == 0) {
-            throw css::container::NoSuchElementException(
-                aName, static_cast< cppu::OWeakObject * >(this));
-        }
-        if (cnst) {
-            unoidl::ConstantValue val1(provider_->getConstant(off));
-            css::uno::Any val2;
-            switch (val1.type) {
-            case unoidl::ConstantValue::TYPE_BOOLEAN:
-                val2 <<= val1.booleanValue;
-                break;
-            case unoidl::ConstantValue::TYPE_BYTE:
-                val2 <<= val1.byteValue;
-                break;
-            case unoidl::ConstantValue::TYPE_SHORT:
-                val2 <<= val1.shortValue;
-                break;
-            case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
-                val2 <<= val1.unsignedShortValue;
-                break;
-            case unoidl::ConstantValue::TYPE_LONG:
-                val2 <<= val1.longValue;
-                break;
-            case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
-                val2 <<= val1.unsignedLongValue;
-                break;
-            case unoidl::ConstantValue::TYPE_HYPER:
-                val2 <<= val1.hyperValue;
-                break;
-            case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
-                val2 <<= val1.unsignedHyperValue;
-                break;
-            case unoidl::ConstantValue::TYPE_FLOAT:
-                val2 <<= val1.floatValue;
-                break;
-            case unoidl::ConstantValue::TYPE_DOUBLE:
-                val2 <<= val1.doubleValue;
-                break;
-            default:
-                for (;;) { std::abort(); } // this cannot happen
-            }
+css::uno::Any cppuhelper::TypeManager::find(rtl::OUString const & name) {
+    //TODO: caching? (here or in unoidl::Manager?)
+    struct Simple {
+        char const * name; sal_Int32 length;
+        css::uno::TypeClass typeClass;
+    };
+    static Simple const simple[] = {
+        { RTL_CONSTASCII_STRINGPARAM("void"), css::uno::TypeClass_VOID },
+        { RTL_CONSTASCII_STRINGPARAM("boolean"), css::uno::TypeClass_BOOLEAN },
+        { RTL_CONSTASCII_STRINGPARAM("byte"), css::uno::TypeClass_BYTE },
+        { RTL_CONSTASCII_STRINGPARAM("short"), css::uno::TypeClass_SHORT },
+        { RTL_CONSTASCII_STRINGPARAM("unsigned short"),
+          css::uno::TypeClass_UNSIGNED_SHORT },
+        { RTL_CONSTASCII_STRINGPARAM("long"), css::uno::TypeClass_LONG },
+        { RTL_CONSTASCII_STRINGPARAM("unsigned long"),
+          css::uno::TypeClass_UNSIGNED_LONG },
+        { RTL_CONSTASCII_STRINGPARAM("hyper"), css::uno::TypeClass_HYPER },
+        { RTL_CONSTASCII_STRINGPARAM("unsigned hyper"),
+          css::uno::TypeClass_UNSIGNED_HYPER },
+        { RTL_CONSTASCII_STRINGPARAM("float"), css::uno::TypeClass_FLOAT },
+        { RTL_CONSTASCII_STRINGPARAM("double"), css::uno::TypeClass_DOUBLE },
+        { RTL_CONSTASCII_STRINGPARAM("char"), css::uno::TypeClass_CHAR },
+        { RTL_CONSTASCII_STRINGPARAM("string"), css::uno::TypeClass_STRING },
+        { RTL_CONSTASCII_STRINGPARAM("type"), css::uno::TypeClass_TYPE },
+        { RTL_CONSTASCII_STRINGPARAM("any"), css::uno::TypeClass_ANY } };
+    for (std::size_t i = 0; i != SAL_N_ELEMENTS(simple); ++i) {
+        if (name.equalsAsciiL(simple[i].name, simple[i].length)) {
             return css::uno::makeAny<
                 css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new ConstantDescription(aName, val2));
-        } else {
-            rtl::Reference< unoidl::Entity > ent(provider_->getEntity(off));
+                    new SimpleTypeDescription(simple[i].typeClass, name));
+        }
+    }
+    if (name.match("[]")) {
+        return getSequenceType(name);
+    }
+    sal_Int32 i = name.indexOf('<');
+    if (i != -1) {
+        return getInstantiatedStruct(name, i);
+    }
+    i = name.indexOf("::");
+    if (i != -1) {
+        return getInterfaceMember(name, i);
+    }
+    rtl::Reference< unoidl::Entity > ent(findEntity(name));
+    if (ent.is()) {
+        return getNamed(name, ent);
+    }
+    i = name.lastIndexOf('.');
+    if (i != -1) {
+        ent = findEntity(name.copy(0, i));
+        if (ent.is()) {
             switch (ent->getSort()) {
-            case unoidl::Entity::SORT_MODULE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ModuleDescription(
-                            context_, aName,
-                            static_cast< unoidl::ModuleEntity * >(ent.get())));
             case unoidl::Entity::SORT_ENUM_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new EnumTypeDescription(
-                            aName,
-                            static_cast< unoidl::EnumTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new PlainStructTypeDescription(
-                            context_, aName,
-                            static_cast< unoidl::PlainStructTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new PolymorphicStructTypeTemplateDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::PolymorphicStructTypeTemplateEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_EXCEPTION_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ExceptionTypeDescription(
-                            context_, aName,
-                            static_cast< unoidl::ExceptionTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_INTERFACE_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new InterfaceTypeDescription(
-                            context_, aName,
-                            static_cast< unoidl::InterfaceTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_TYPEDEF:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new TypedefDescription(
-                            context_, aName,
-                            static_cast< unoidl::TypedefEntity * >(ent.get())));
+                return getEnumMember(
+                    static_cast< unoidl::EnumTypeEntity * >(ent.get()),
+                    name.copy(i + 1));
             case unoidl::Entity::SORT_CONSTANT_GROUP:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ConstantGroupDescription(
-                            context_, aName,
-                            static_cast< unoidl::ConstantGroupEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new SingleInterfaceBasedServiceDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::SingleInterfaceBasedServiceEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new AccumulationBasedServiceDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::AccumulationBasedServiceEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new InterfaceBasedSingletonDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::InterfaceBasedSingletonEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ServiceBasedSingletonDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::ServiceBasedSingletonEntity * >(
-                                    ent.get())));
+                return getConstant(
+                    static_cast< unoidl::ConstantGroupEntity * >(ent.get()),
+                    name.copy(i + 1));
             default:
-                for (;;) { std::abort(); } // this cannot happen
+                break;
             }
         }
-    } catch (unoidl::FileFormatException & e) {
+    }
+    return css::uno::Any();
+}
+
+css::uno::Reference< css::reflection::XTypeDescription >
+cppuhelper::TypeManager::resolve(rtl::OUString const & name) {
+    css::uno::Reference< css::reflection::XTypeDescription > desc(
+        find(name), css::uno::UNO_QUERY);
+    if (!desc.is()) {
         throw css::uno::DeploymentException(
-            e.getUri() + ": " + e.getDetail(),
+            "cannot resolve type \"" + name + "\"",
             static_cast< cppu::OWeakObject * >(this));
     }
+    return desc;
 }
 
-sal_Bool Provider::hasByHierarchicalName(
-    rtl::OUString const & aName) throw (css::uno::RuntimeException)
+cppuhelper::TypeManager::~TypeManager() throw () {}
+
+void cppuhelper::TypeManager::disposing() {} //TODO
+
+rtl::OUString cppuhelper::TypeManager::getImplementationName()
+    throw (css::uno::RuntimeException)
 {
-    try {
-        return provider_->find(aName) != 0;
-    } catch (unoidl::FileFormatException & e) {
-        throw css::uno::DeploymentException(
-            e.getUri() + ": " + e.getDetail(),
-            static_cast< cppu::OWeakObject * >(this));
+    return rtl::OUString(
+        "com.sun.star.comp.cppuhelper.bootstrap.TypeManager");
+}
+
+sal_Bool cppuhelper::TypeManager::supportsService(
+    rtl::OUString const & ServiceName)
+    throw (css::uno::RuntimeException)
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence< rtl::OUString >
+cppuhelper::TypeManager::getSupportedServiceNames()
+    throw (css::uno::RuntimeException)
+{
+    css::uno::Sequence< rtl::OUString > names(1);
+    names[0] = "com.sun.star.reflection.TypeDescriptionManager"; //TODO
+    return names;
+}
+
+css::uno::Any cppuhelper::TypeManager::getByHierarchicalName(
+    rtl::OUString const & aName)
+    throw (css::container::NoSuchElementException, css::uno::RuntimeException)
+{
+    css::uno::Any desc(find(aName));
+    if (!desc.hasValue()) {
+        throw css::container::NoSuchElementException(
+            aName, static_cast< cppu::OWeakObject * >(this));
     }
+    return desc;
+}
+
+sal_Bool cppuhelper::TypeManager::hasByHierarchicalName(
+    rtl::OUString const & aName)
+    throw (css::uno::RuntimeException)
+{
+    return find(aName).hasValue();
+}
+
+css::uno::Type cppuhelper::TypeManager::getElementType()
+    throw (css::uno::RuntimeException)
+{
+    return cppu::UnoType< rtl::OUString >::get();
+}
+
+sal_Bool cppuhelper::TypeManager::hasElements()
+    throw (css::uno::RuntimeException)
+{
+    throw css::uno::RuntimeException(
+        "TypeManager hasElements: method not supported",
+        static_cast< cppu::OWeakObject * >(this));
+}
+
+css::uno::Reference< css::container::XEnumeration >
+cppuhelper::TypeManager::createEnumeration()
+    throw (css::uno::RuntimeException)
+{
+    throw css::uno::RuntimeException(
+        "TypeManager createEnumeration: method not supported",
+        static_cast< cppu::OWeakObject * >(this));
+}
+
+sal_Bool cppuhelper::TypeManager::has(css::uno::Any const &)
+    throw (css::uno::RuntimeException)
+{
+    throw css::uno::RuntimeException(
+        "TypeManager has: method not supported",
+        static_cast< cppu::OWeakObject * >(this));
+}
+
+void cppuhelper::TypeManager::insert(css::uno::Any const & aElement)
+    throw (
+        css::lang::IllegalArgumentException,
+        css::container::ElementExistException, css::uno::RuntimeException)
+{
+    rtl::OUString uri;
+    if (!(aElement >>= uri)) {
+        throw css::lang::IllegalArgumentException(
+            ("css.uno.theTypeDescriptionManager.insert expects a string URI"
+             " argument"),
+            static_cast< cppu::OWeakObject * >(this), 0);
+    }
+    //TODO: check for ElementExistException
+    //TODO: check for consistency with existing data
+    readRdbFile(uri, false);
+}
+
+void cppuhelper::TypeManager::remove(css::uno::Any const & aElement)
+    throw (
+        css::lang::IllegalArgumentException,
+        css::container::NoSuchElementException, css::uno::RuntimeException)
+{
+    rtl::OUString uri;
+    if (!(aElement >>= uri)) {
+        throw css::lang::IllegalArgumentException(
+            ("css.uno.theTypeDescriptionManager.remove expects a string URI"
+             " argument"),
+            static_cast< cppu::OWeakObject * >(this), 0);
+    }
+    //TODO: remove requests are silently ignored for now
 }
 
 css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
-Provider::createTypeDescriptionEnumeration(
+cppuhelper::TypeManager::createTypeDescriptionEnumeration(
     rtl::OUString const & moduleName,
     css::uno::Sequence< css::uno::TypeClass > const & types,
     css::reflection::TypeDescriptionSearchDepth depth)
-    throw(
+    throw (
         css::reflection::NoSuchTypeNameException,
-        css::reflection::InvalidTypeNameException, css::uno::RuntimeException)
+        css::reflection::InvalidTypeNameException,
+        css::uno::RuntimeException)
 {
+    //TODO: This fails for modules spread across multiple providers, esp. for
+    // the empty moduleName
+    rtl::Reference< unoidl::Entity > ent(findEntity(moduleName));
+    if (!ent.is()) {
+        throw css::reflection::NoSuchTypeNameException(
+            moduleName, static_cast< cppu::OWeakObject * >(this));
+    }
+    if (ent->getSort() != unoidl::Entity::SORT_MODULE) {
+        throw css::reflection::InvalidTypeNameException(
+            moduleName, static_cast< cppu::OWeakObject * >(this));
+    }
+    rtl::Reference< unoidl::MapCursor > cursor;
     try {
-        rtl::OUString prefix;
-        rtl::Reference< unoidl::MapCursor > cursor;
-        if (moduleName.isEmpty()) {
-            cursor = provider_->createRootCursor();
-        } else {
-            prefix = moduleName + ".";
-            bool cnst;
-            sal_uInt32 off = provider_->find(moduleName, &cnst);
-            if (off == 0) {
-                throw css::reflection::NoSuchTypeNameException(
-                    moduleName, static_cast< cppu::OWeakObject * >(this));
-            }
-            if (cnst) {
-                throw css::reflection::InvalidTypeNameException(
-                    moduleName, static_cast< cppu::OWeakObject * >(this));
-            }
-            rtl::Reference< unoidl::Entity > ent(provider_->getEntity(off));
-            if (ent->getSort() != unoidl::Entity::SORT_MODULE) {
-                throw css::reflection::InvalidTypeNameException(
-                    moduleName, static_cast< cppu::OWeakObject * >(this));
-            }
-            cursor = static_cast< unoidl::ModuleEntity * >(ent.get())->
-                createCursor();
-        }
-        return new Enumeration(
-            context_, prefix, cursor, types,
-            depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
+        cursor = static_cast< unoidl::ModuleEntity * >(ent.get())->
+            createCursor();
     } catch (unoidl::FileFormatException & e) {
         throw css::uno::DeploymentException(
-            e.getUri() + ": " + e.getDetail(),
+            ("unoidl::FileFormatException for <" + e.getUri() + ">: "
+             + e.getDetail()),
             static_cast< cppu::OWeakObject * >(this));
     }
+    return new Enumeration(
+        this, moduleName + ".", cursor, types,
+        depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
 }
 
-css::uno::Reference< css::container::XHierarchicalNameAccess >
-readLegacyRdbFile(
-    rtl::OUString const & uri,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context)
-{
-    assert(serviceManager.is());
-    css::uno::Reference< css::registry::XSimpleRegistry > reg(
-        serviceManager->createInstanceWithContext(
-            "com.sun.star.comp.stoc.SimpleRegistry", context),
-        css::uno::UNO_QUERY_THROW);
-    try {
-        reg->open(uri, true, false);
-    } catch (css::registry::InvalidRegistryException & e) {
-        throw css::uno::DeploymentException(
-            "Invalid registry " + uri + ":" + e.Message,
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    css::uno::Sequence< css::uno::Any > arg(1);
-    arg[0] <<= reg;
-    return css::uno::Reference< css::container::XHierarchicalNameAccess >(
-        serviceManager->createInstanceWithArgumentsAndContext(
-            "com.sun.star.comp.stoc.RegistryTypeDescriptionProvider", arg,
-            context),
-        css::uno::UNO_QUERY_THROW);
-}
-
-void readRdbFile(
-    rtl::OUString const & uri, bool optional,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context,
-    std::vector<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > *
-            providers)
-{
-    assert(providers != 0);
-    css::uno::Reference< css::container::XHierarchicalNameAccess > prov;
-    try {
-        prov = new Provider(context, uri);
-    } catch (unoidl::NoSuchFileException &) {
-        if (optional) {
-            SAL_INFO("cppuhelper", "Ignored optional " << uri);
-            return;
+void cppuhelper::TypeManager::readRdbs(rtl::OUString const & uris) {
+    for (sal_Int32 i = 0; i != -1;) {
+        rtl::OUString uri(uris.getToken(0, ' ', i));
+        if (uri.isEmpty()) {
+            continue;
+        }
+        bool optional;
+        bool directory;
+        cppu::decodeRdbUri(&uri, &optional, &directory);
+        if (directory) {
+            readRdbDirectory(uri, optional);
+        } else {
+            readRdbFile(uri, optional);
         }
-        throw css::uno::DeploymentException(
-            uri + ": no such file",
-            css::uno::Reference< css::uno::XInterface >());
-    } catch (unoidl::FileFormatException &) {
-        prov = readLegacyRdbFile(uri, serviceManager, context);
     }
-    assert(prov.is());
-    providers->push_back(prov);
 }
 
-void readRdbDirectory(
-    rtl::OUString const & uri, bool optional,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context,
-    std::vector<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > *
-            providers)
+void cppuhelper::TypeManager::readRdbDirectory(
+    rtl::OUString const & uri, bool optional)
 {
     osl::Directory dir(uri);
     switch (dir.open()) {
@@ -2020,54 +2113,258 @@ void readRdbDirectory(
     default:
         throw css::uno::DeploymentException(
             "Cannot open directory " + uri,
-            css::uno::Reference< css::uno::XInterface >());
+            static_cast< cppu::OWeakObject * >(this));
     }
     for (;;) {
-        rtl::OUString fileUri;
-        if (!cppu::nextDirectoryItem(dir, &fileUri)) {
+        rtl::OUString url;
+        if (!cppu::nextDirectoryItem(dir, &url)) {
             break;
         }
-        readRdbFile(fileUri, optional, serviceManager, context, providers);
+        readRdbFile(url, false);
     }
 }
 
+void cppuhelper::TypeManager::readRdbFile(
+    rtl::OUString const & uri, bool optional)
+{
+    rtl::Reference< unoidl::Provider > prov;
+    try {
+        prov = unoidl::loadProvider(manager_, uri);
+    } catch (unoidl::NoSuchFileException &) {
+        if (!optional) {
+            throw css::uno::DeploymentException(
+                uri + ": no such file",
+                static_cast< cppu::OWeakObject * >(this));
+        }
+        SAL_INFO("cppuhelper", "Ignored optional " << uri);
+    } catch (unoidl::FileFormatException & e) {
+            throw css::uno::DeploymentException(
+                ("unoidl::FileFormatException for <" + e.getUri() + ">: "
+                 + e.getDetail()),
+                static_cast< cppu::OWeakObject * >(this));
+    }
+    manager_->addProvider(prov);
 }
 
-css::uno::Sequence<
-    css::uno::Reference< css::container::XHierarchicalNameAccess > >
-cppuhelper::createTypeDescriptionProviders(
-    rtl::OUString const & uris,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context)
-{
-    std::vector<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > provs;
-    for (sal_Int32 i = 0; i != -1;) {
-        rtl::OUString uri(uris.getToken(0, ' ', i));
-        if (uri.isEmpty()) {
-            continue;
+css::uno::Any cppuhelper::TypeManager::getSequenceType(
+    rtl::OUString const & name)
+{
+    assert(name.match("[]"));
+    return css::uno::makeAny<
+        css::uno::Reference< css::reflection::XTypeDescription > >(
+            new SequenceTypeDescription(
+                this, name, name.copy(std::strlen("[]"))));
+}
+
+css::uno::Any cppuhelper::TypeManager::getInstantiatedStruct(
+    rtl::OUString const & name, sal_Int32 separator)
+{
+    assert(name.indexOf('<') == separator && separator != -1);
+    rtl::Reference< unoidl::Entity > ent(findEntity(name.copy(0, separator)));
+    if (!ent.is()
+        || (ent->getSort()
+            != unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE))
+    {
+        return css::uno::Any();
+    }
+    rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > ent2(
+        static_cast< unoidl::PolymorphicStructTypeTemplateEntity * >(
+            ent.get()));
+    std::vector< rtl::OUString > args;
+    sal_Int32 i = separator;
+    do {
+        ++i; // skip '<' or ','
+        sal_Int32 j = i;
+        for (sal_Int32 level = 0; j != name.getLength(); ++j) {
+            sal_Unicode c = name[j];
+            if (c == ',') {
+                if (level == 0) {
+                    break;
+                }
+            } else if (c == '<') {
+                ++level;
+            } else if (c == '>') {
+                if (level == 0) {
+                    break;
+                }
+                --level;
+            }
         }
-        bool optional;
-        bool directory;
-        cppu::decodeRdbUri(&uri, &optional, &directory);
-        if (directory) {
-            readRdbDirectory(uri, optional, serviceManager, context, &provs);
-        } else {
-            readRdbFile(uri, optional, serviceManager, context, &provs);
+        if (j != name.getLength()) {
+            args.push_back(name.copy(i, j - i));
         }
+        i = j;
+    } while (i != name.getLength() && name[i] != '>');
+    if (i != name.getLength() - 1 || name[i] != '>'
+        || args.size() != ent2->getTypeParameters().size())
+    {
+        return css::uno::Any();
     }
+    return css::uno::makeAny<
+        css::uno::Reference< css::reflection::XTypeDescription > >(
+            new InstantiatedPolymorphicStructTypeDescription(
+                this, name, ent2, args));
+}
+
+css::uno::Any cppuhelper::TypeManager::getInterfaceMember(
+    rtl::OUString const & name, sal_Int32 separator)
+{
+    assert(name.indexOf("::") == separator && separator != -1);
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > ifc(
+        resolveTypedefs(find(name.copy(0, separator))), css::uno::UNO_QUERY);
+    if (!ifc.is()) {
+        return css::uno::Any();
+    }
+    rtl::OUString member(name.copy(separator + std::strlen("::")));
     css::uno::Sequence<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > provs2(
-            static_cast< sal_Int32 >(provs.size())); //TODO: check overflow
-    std::vector<
         css::uno::Reference<
-            css::container::XHierarchicalNameAccess > >::iterator i(
-                provs.begin());
-    for (sal_Int32 j = 0; j != provs2.getLength(); ++j) {
-        provs2[j] = *i++;
+            css::reflection::XInterfaceMemberTypeDescription > > mems(
+                ifc->getMembers());
+    for (sal_Int32 i = 0; i != mems.getLength(); ++i) {
+        if (mems[i]->getMemberName() == member) {
+            return css::uno::makeAny<
+                css::uno::Reference< css::reflection::XTypeDescription > >(
+                    mems[i].get());
+        }
+    }
+    return css::uno::Any();
+}
+
+css::uno::Any cppuhelper::TypeManager::getNamed(
+    rtl::OUString const & name, rtl::Reference< unoidl::Entity > entity)
+{
+    assert(entity.is());
+    switch (entity->getSort()) {
+    case unoidl::Entity::SORT_MODULE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new ModuleDescription(
+                    this, name,
+                    static_cast< unoidl::ModuleEntity * >(entity.get())));
+    case unoidl::Entity::SORT_ENUM_TYPE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new EnumTypeDescription(
+                    name,
+                    static_cast< unoidl::EnumTypeEntity * >(entity.get())));
+    case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new PlainStructTypeDescription(
+                    this, name,
+                    static_cast< unoidl::PlainStructTypeEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new PolymorphicStructTypeTemplateDescription(
+                    this, name,
+                    static_cast<
+                        unoidl::PolymorphicStructTypeTemplateEntity * >(
+                            entity.get())));
+    case unoidl::Entity::SORT_EXCEPTION_TYPE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new ExceptionTypeDescription(
+                    this, name,
+                    static_cast< unoidl::ExceptionTypeEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_INTERFACE_TYPE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new InterfaceTypeDescription(
+                    this, name,
+                    static_cast< unoidl::InterfaceTypeEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_TYPEDEF:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new TypedefDescription(
+                    this, name,
+                    static_cast< unoidl::TypedefEntity * >(entity.get())));
+    case unoidl::Entity::SORT_CONSTANT_GROUP:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new ConstantGroupDescription(
+                    name,
+                    static_cast< unoidl::ConstantGroupEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new SingleInterfaceBasedServiceDescription(
+                    this, name,
+                    static_cast< unoidl::SingleInterfaceBasedServiceEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new AccumulationBasedServiceDescription(
+                    this, name,
+                    static_cast< unoidl::AccumulationBasedServiceEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new InterfaceBasedSingletonDescription(
+                    this, name,
+                    static_cast< unoidl::InterfaceBasedSingletonEntity * >(
+                        entity.get())));
+    case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new ServiceBasedSingletonDescription(
+                    this, name,
+                    static_cast< unoidl::ServiceBasedSingletonEntity * >(
+                        entity.get())));
+    default:
+        for (;;) { std::abort(); } // this cannot happen
+    }
+}
+
+css::uno::Any cppuhelper::TypeManager::getEnumMember(
+    rtl::Reference< unoidl::EnumTypeEntity > entity,
+    rtl::OUString const & member)
+{
+    for (std::vector< unoidl::EnumTypeEntity::Member >::const_iterator i(
+             entity->getMembers().begin());
+         i != entity->getMembers().end(); ++i)
+    {
+        if (i->name == member) {
+            return css::uno::makeAny(i->value);
+        }
+    }
+    return css::uno::Any();
+}
+
+css::uno::Any cppuhelper::TypeManager::getConstant(
+    rtl::Reference< unoidl::ConstantGroupEntity > entity,
+    rtl::OUString const & member)
+{
+    for (std::vector< unoidl::ConstantGroupEntity::Member >::const_iterator i(
+             entity->getMembers().begin());
+         i != entity->getMembers().end(); ++i)
+    {
+        if (i->name == member) {
+            return css::uno::makeAny<
+                css::uno::Reference< css::reflection::XTypeDescription > >(
+                    new ConstantDescription(*i));
+        }
+    }
+    return css::uno::Any();
+}
+
+rtl::Reference< unoidl::Entity > cppuhelper::TypeManager::findEntity(
+    rtl::OUString const & name)
+{
+    try {
+        return manager_->findEntity(name);
+    } catch (unoidl::FileFormatException & e) {
+        throw css::uno::DeploymentException(
+            ("unoidl::FileFormatException for <" + e.getUri() + ">: "
+             + e.getDetail()),
+            static_cast< cppu::OWeakObject * >(this));
     }
-    return provs2;
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppuhelper/source/typemanager.hxx b/cppuhelper/source/typemanager.hxx
new file mode 100644
index 000000000000..a84a2319f3a0
--- /dev/null
+++ b/cppuhelper/source/typemanager.hxx
@@ -0,0 +1,151 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDED_CPPUHELPER_SOURCE_TYPEMANAGER_HXX
+#define INCLUDED_CPPUHELPER_SOURCE_TYPEMANAGER_HXX
+
+#include "sal/config.h"
+
+#include "com/sun/star/container/ElementExistException.hpp"
+#include "com/sun/star/container/NoSuchElementException.hpp"
+#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
+#include "com/sun/star/container/XSet.hpp"
+#include "com/sun/star/lang/IllegalArgumentException.hpp"
+#include "com/sun/star/lang/XServiceInfo.hpp"
+#include "com/sun/star/reflection/InvalidTypeNameException.hpp"
+#include "com/sun/star/reflection/NoSuchTypeNameException.hpp"
+#include "com/sun/star/reflection/TypeDescriptionSearchDepth.hpp"
+#include "com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp"
+#include "com/sun/star/uno/Reference.hxx"
+#include "com/sun/star/uno/RuntimeException.hpp"
+#include "com/sun/star/uno/Sequence.hxx"
+#include "cppuhelper/compbase4.hxx"
+#include "osl/mutex.hxx"
+#include "rtl/ref.hxx"
+#include "sal/types.h"
+
+namespace com { namespace sun { namespace star {
+    namespace uno { class Any; }
+    namespace reflection { class XTypeDescription; }
+} } }
+namespace rtl { class OUString; }
+namespace unoidl {
+    class ConstantGroupEntity;
+    class Entity;
+    class EnumTypeEntity;
+    class Manager;
+}
+
+namespace cppuhelper {
+
+typedef cppu::WeakComponentImplHelper4<
+    css::lang::XServiceInfo, css::container::XHierarchicalNameAccess,
+    css::container::XSet, css::reflection::XTypeDescriptionEnumerationAccess >
+TypeManager_Base;
+
+class TypeManager: private osl::Mutex, public TypeManager_Base {
+public:
+    explicit TypeManager(rtl::OUString const & rdbUris);
+
+    using TypeManager_Base::acquire;
+    using TypeManager_Base::release;
+
+    css::uno::Any find(rtl::OUString const & name);
+
+    css::uno::Reference< css::reflection::XTypeDescription > resolve(
+        rtl::OUString const & name);
+
+private:
+    virtual ~TypeManager() throw ();
+
+    virtual void SAL_CALL disposing();
+
+    virtual rtl::OUString SAL_CALL getImplementationName()
+        throw (css::uno::RuntimeException);
+
+    virtual sal_Bool SAL_CALL supportsService(rtl::OUString const & ServiceName)
+        throw (css::uno::RuntimeException);
+
+    virtual css::uno::Sequence< rtl::OUString > SAL_CALL
+    getSupportedServiceNames() throw (css::uno::RuntimeException);
+
+    virtual css::uno::Any SAL_CALL getByHierarchicalName(
+        rtl::OUString const & aName)
+        throw (
+            css::container::NoSuchElementException, css::uno::RuntimeException);
+
+    virtual sal_Bool SAL_CALL hasByHierarchicalName(rtl::OUString const & aName)
+        throw (css::uno::RuntimeException);
+
+    virtual css::uno::Type SAL_CALL getElementType()
+        throw (css::uno::RuntimeException);
+
+    virtual sal_Bool SAL_CALL hasElements() throw (css::uno::RuntimeException);
+
+    virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL
+    createEnumeration() throw (css::uno::RuntimeException);
+
+    virtual sal_Bool SAL_CALL has(css::uno::Any const & aElement)
+        throw (css::uno::RuntimeException);
+
+    virtual void SAL_CALL insert(css::uno::Any const & aElement)
+        throw (
+            css::lang::IllegalArgumentException,
+            css::container::ElementExistException, css::uno::RuntimeException);
+
+    virtual void SAL_CALL remove(css::uno::Any const & aElement)
+        throw (
+            css::lang::IllegalArgumentException,
+            css::container::NoSuchElementException, css::uno::RuntimeException);
+
+    virtual css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
+    SAL_CALL createTypeDescriptionEnumeration(
+        rtl::OUString const & moduleName,
+        css::uno::Sequence< css::uno::TypeClass > const & types,
+        css::reflection::TypeDescriptionSearchDepth depth)
+        throw (
+            css::reflection::NoSuchTypeNameException,
+            css::reflection::InvalidTypeNameException,
+            css::uno::RuntimeException);
+
+    void readRdbs(rtl::OUString const & uris);
+
+    void readRdbDirectory(rtl::OUString const & uri, bool optional);
+
+    void readRdbFile(rtl::OUString const & uri, bool optional);
+
+    css::uno::Any getSequenceType(rtl::OUString const & name);
+
+    css::uno::Any getInstantiatedStruct(
+        rtl::OUString const & name, sal_Int32 separator);
+
+    css::uno::Any getInterfaceMember(
+        rtl::OUString const & name, sal_Int32 separator);
+
+    css::uno::Any getNamed(
+        rtl::OUString const & name, rtl::Reference< unoidl::Entity > entity);
+
+    css::uno::Any getEnumMember(
+        rtl::Reference< unoidl::EnumTypeEntity > entity,
+        rtl::OUString const & member);
+
+    css::uno::Any getConstant(
+        rtl::Reference< unoidl::ConstantGroupEntity > entity,
+        rtl::OUString const & member);
+
+    rtl::Reference< unoidl::Entity > findEntity(rtl::OUString const & name);
+
+    rtl::Reference< unoidl::Manager > manager_;
+};
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/desktop/source/deployment/registry/component/dp_component.cxx b/desktop/source/deployment/registry/component/dp_component.cxx
index e72aa32883a0..66cfd4b9bb89 100644
--- a/desktop/source/deployment/registry/component/dp_component.cxx
+++ b/desktop/source/deployment/registry/component/dp_component.cxx
@@ -35,7 +35,6 @@
 #include "svl/inettype.hxx"
 #include "com/sun/star/lang/WrappedTargetRuntimeException.hpp"
 #include "com/sun/star/container/XNameContainer.hpp"
-#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
 #include "com/sun/star/container/XSet.hpp"
 #include "com/sun/star/registry/XSimpleRegistry.hpp"
 #include "com/sun/star/registry/XImplementationRegistration.hpp"
@@ -183,7 +182,6 @@ class BackendImpl : public ::dp_registry::backend::PackageRegistryBackend
         BackendImpl * getMyBackend() const;
 
         const bool m_jarFile;
-        Reference<container::XHierarchicalNameAccess> m_xTDprov;
 
         virtual void SAL_CALL disposing();
 
@@ -400,7 +398,6 @@ void BackendImpl::ComponentPackageImpl::disposing()
 //______________________________________________________________________________
 void BackendImpl::TypelibraryPackageImpl::disposing()
 {
-    m_xTDprov.clear();
     Package::disposing();
 }
 
@@ -1532,37 +1529,12 @@ void BackendImpl::TypelibraryPackageImpl::processPackage_(
         }
         else // RDB:
         {
-            Reference<XComponentContext> const & xContext =
-                that->getComponentContext();
-            if (! m_xTDprov.is())
-            {
-                m_xTDprov.set( that->getObject( url ), UNO_QUERY );
-                if (! m_xTDprov.is())
-                {
-                    const Reference<registry::XSimpleRegistry> xReg(
-                        xContext->getServiceManager()
-                        ->createInstanceWithContext("com.sun.star.registry.SimpleRegistry",
-                            xContext ), UNO_QUERY_THROW );
-                    xReg->open( expandUnoRcUrl(url),
-                                true /* read-only */, false /* ! create */ );
-                    const Any arg(xReg);
-                    Reference<container::XHierarchicalNameAccess> xTDprov(
-                        xContext->getServiceManager()
-                        ->createInstanceWithArgumentsAndContext(
-                            "com.sun.star.comp.stoc.RegistryTypeDescriptionProvider",
-                            Sequence<Any>( &arg, 1 ), xContext ), UNO_QUERY );
-                    OSL_ASSERT( xTDprov.is() );
-                    if (xTDprov.is())
-                        m_xTDprov.set( that->insertObject( url, xTDprov ),
-                                       UNO_QUERY_THROW );
-                }
-            }
-            if (m_xTDprov.is()) {
-                Reference<container::XSet> xSet(
-                    xContext->getValueByName( "/singletons/com.sun.star.reflection.theTypeDescriptionManager" ),
-                    UNO_QUERY_THROW );
-                xSet->insert( Any(m_xTDprov) );
-            }
+            css::uno::Reference< css::container::XSet >(
+                that->getComponentContext()->getValueByName(
+                    "/singletons"
+                    "/com.sun.star.reflection.theTypeDescriptionManager"),
+                css::uno::UNO_QUERY_THROW)->insert(
+                    css::uno::makeAny(expandUnoRcUrl(url)));
         }
 
         that->addToUnoRc( m_jarFile ? RCITEM_JAR_TYPELIB : RCITEM_RDB_TYPELIB,
@@ -1574,18 +1546,13 @@ void BackendImpl::TypelibraryPackageImpl::processPackage_(
             m_jarFile ? RCITEM_JAR_TYPELIB : RCITEM_RDB_TYPELIB, url, xCmdEnv );
 
         // revoking types at runtime, possible, sensible?
-        if (!m_xTDprov.is())
-            m_xTDprov.set( that->getObject( url ), UNO_QUERY );
-        if (m_xTDprov.is()) {
-            // remove live:
-            const Reference<container::XSet> xSet(
+        if (!m_jarFile) {
+            css::uno::Reference< css::container::XSet >(
                 that->getComponentContext()->getValueByName(
-                    "/singletons/com.sun.star.reflection.theTypeDescriptionManager" ),
-                UNO_QUERY_THROW );
-            xSet->remove( Any(m_xTDprov) );
-
-            that->releaseObject( url );
-            m_xTDprov.clear();
+                    "/singletons"
+                    "/com.sun.star.reflection.theTypeDescriptionManager"),
+                css::uno::UNO_QUERY_THROW)->remove(
+                    css::uno::makeAny(expandUnoRcUrl(url)));
         }
     }
 }
diff --git a/stoc/Library_bootstrap.mk b/stoc/Library_bootstrap.mk
index 0a08b174b7d9..7615a5c2026e 100644
--- a/stoc/Library_bootstrap.mk
+++ b/stoc/Library_bootstrap.mk
@@ -67,9 +67,6 @@ $(eval $(call gb_Library_add_exception_objects,bootstrap,\
     stoc/source/security/permissions \
     stoc/source/servicemanager/servicemanager \
     stoc/source/simpleregistry/simpleregistry \
-    stoc/source/tdmanager/tdmgr \
-    stoc/source/tdmanager/tdmgr_check \
-    stoc/source/tdmanager/tdmgr_tdenumeration \
 ))
 
 # vim:set noet sw=4 ts=4:
diff --git a/stoc/inc/bootstrapservices.hxx b/stoc/inc/bootstrapservices.hxx
index 57b9ca907cb0..a754d13a543c 100644
--- a/stoc/inc/bootstrapservices.hxx
+++ b/stoc/inc/bootstrapservices.hxx
@@ -91,13 +91,6 @@ namespace stoc_bootstrap
     throw(::com::sun::star::uno::Exception);
     ::com::sun::star::uno::Sequence< OUString > rdbtdp_getSupportedServiceNames();
     OUString rdbtdp_getImplementationName();
-
-    //tdmanager
-    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL ManagerImpl_create(
-        const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& )
-    SAL_THROW( (::com::sun::star::uno::Exception) );
-    ::com::sun::star::uno::Sequence< OUString > SAL_CALL tdmgr_getSupportedServiceNames();
-    OUString SAL_CALL tdmgr_getImplementationName();
 } // namespace
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/bootstrap/services.cxx b/stoc/source/bootstrap/services.cxx
index 3157d2556f00..b35295facc7a 100644
--- a/stoc/source/bootstrap/services.cxx
+++ b/stoc/source/bootstrap/services.cxx
@@ -94,12 +94,6 @@ static struct ImplementationEntry g_entries[] =
     rdbtdp_getSupportedServiceNames, createSingleComponentFactory,
     0, 0
     },
-    //tdmanager
-    {
-    ManagerImpl_create, tdmgr_getImplementationName,
-    tdmgr_getSupportedServiceNames, createSingleComponentFactory,
-    0, 0
-    },
     //end
     { 0, 0, 0, 0, 0, 0 }
 };
diff --git a/stoc/source/tdmanager/lrucache.hxx b/stoc/source/tdmanager/lrucache.hxx
deleted file mode 100644
index 0ab1712fb793..000000000000
--- a/stoc/source/tdmanager/lrucache.hxx
+++ /dev/null
@@ -1,242 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-#ifndef _LRU_CACHE_HXX_
-#define _LRU_CACHE_HXX_
-
-// __CACHE_DIAGNOSE forces cache size to 4 and works only for OUString keys
-//  #define __CACHE_DIAGNOSE 1
-
-#include <osl/mutex.hxx>
-#include "rtl/ustring.hxx"
-#include "sal/log.hxx"
-
-#include <boost/unordered_map.hpp>
-
-
-/** Implementation of a least recently used (lru) cache.
-    <br>
-    @author Daniel Boelzle
-*/
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-class LRU_Cache
-{
-    struct CacheEntry
-    {
-        t_Key               aKey;
-        t_Val               aVal;
-        CacheEntry *        pPred;
-        CacheEntry *        pSucc;
-    };
-    typedef ::boost::unordered_map< t_Key, CacheEntry *, t_KeyHash, t_KeyEqual > t_Key2Element;
-
-    mutable ::osl::Mutex        _aCacheMutex;
-    sal_Int32                   _nCachedElements;
-    t_Key2Element               _aKey2Element;
-
-    CacheEntry *                _pBlock;
-    mutable CacheEntry *        _pHead;
-    mutable CacheEntry *        _pTail;
-    inline void toFront( CacheEntry * pEntry ) const;
-
-public:
-    /** Constructor:
-        <br>
-        @param nCachedElements number of elements to be cached; default param set to 128
-    */
-    inline LRU_Cache( sal_Int32 nCachedElements = 128 );
-    /** Destructor: releases all cached elements and keys.
-        <br>
-    */
-    inline ~LRU_Cache();
-
-    /** Retrieves a value from the cache. Returns default constructed value,
-        if none was found.
-        <br>
-        @param rKey a key
-        @return value
-    */
-    inline t_Val getValue( t_Key const & rKey ) const;
-    /** Sets a value to be cached for given key.
-        <br>
-        @param rKey a key
-        @param rValue a value
-    */
-    inline void setValue( t_Key const & rKey, t_Val const & rValue );
-    /** Tests whether a value is cached for given key.
-        <br>
-        @param rKey a key
-        @return true, if value is cached
-    */
-    inline sal_Bool hasValue( t_Key const & rKey ) const;
-    /** Clears the cache, thus releasing all cached elements and keys.
-        <br>
-    */
-    inline void clear();
-};
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::LRU_Cache( sal_Int32 nCachedElements )
-#ifdef __CACHE_DIAGNOSE
-    : _nCachedElements( 4 )
-#else
-    : _nCachedElements( nCachedElements )
-#endif
-    , _pBlock( 0 )
-{
-    if (_nCachedElements > 0)
-    {
-        _pBlock = new CacheEntry[_nCachedElements];
-        _pHead  = _pBlock;
-        _pTail  = _pBlock + _nCachedElements -1;
-        for ( sal_Int32 nPos = _nCachedElements; nPos--; )
-        {
-            _pBlock[nPos].pPred = _pBlock + nPos -1;
-            _pBlock[nPos].pSucc = _pBlock + nPos +1;
-        }
-    }
-}
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::~LRU_Cache()
-{
-    delete [] _pBlock;
-}
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline void LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::toFront(
-    CacheEntry * pEntry ) const
-{
-    if (pEntry != _pHead)
-    {
-        // cut out element
-        if (pEntry == _pTail)
-        {
-            _pTail = pEntry->pPred;
-        }
-        else
-        {
-            pEntry->pSucc->pPred = pEntry->pPred;
-            pEntry->pPred->pSucc = pEntry->pSucc;
-        }
-        // push to front
-        _pHead->pPred = pEntry;
-        pEntry->pSucc = _pHead;
-        _pHead        = pEntry;
-    }
-}
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline sal_Bool LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::hasValue(
-    t_Key const & rKey ) const
-{
-    ::osl::MutexGuard aGuard( _aCacheMutex );
-    typename t_Key2Element::const_iterator const iFind( _aKey2Element.find( rKey ) );
-    return (iFind != _aKey2Element.end());
-}
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline t_Val LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::getValue(
-    t_Key const & rKey ) const
-{
-    ::osl::MutexGuard aGuard( _aCacheMutex );
-    const typename t_Key2Element::const_iterator iFind( _aKey2Element.find( rKey ) );
-    if (iFind != _aKey2Element.end())
-    {
-        CacheEntry * pEntry = (*iFind).second;
-        toFront( pEntry );
-#ifdef __CACHE_DIAGNOSE
-        SAL_INFO("stoc.tdmanager", "> retrieved element \"" );
-        SAL_INFO("stoc.tdmanager", "" << pEntry->aKey);
-        SAL_INFO("stoc.tdmanager", "\" from cache <" );
-#endif
-        return pEntry->aVal;
-    }
-    return t_Val();
-}
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline void LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::setValue(
-    t_Key const & rKey, t_Val const & rValue )
-{
-    if (_nCachedElements > 0)
-    {
-        ::osl::MutexGuard aGuard( _aCacheMutex );
-        typename t_Key2Element::const_iterator const iFind( _aKey2Element.find( rKey ) );
-
-        CacheEntry * pEntry;
-        if (iFind == _aKey2Element.end())
-        {
-            pEntry = _pTail; // erase last element
-#ifdef __CACHE_DIAGNOSE
-            if (pEntry->aKey.getLength())
-            {
-                SAL_INFO("stoc.tdmanager", "> kicking element \"" );
-                SAL_INFO("stoc.tdmanager", "" << pEntry->aKey);
-                SAL_INFO("stoc.tdmanager", "\" from cache <" );
-            }
-#endif
-            _aKey2Element.erase( pEntry->aKey );
-            _aKey2Element[ pEntry->aKey = rKey ] = pEntry;
-        }
-        else
-        {
-            pEntry = (*iFind).second;
-#ifdef __CACHE_DIAGNOSE
-            SAL_INFO("stoc.tdmanager", "> replacing element \"" );
-            SAL_INFO("stoc.tdmanager", "" << pEntry->aKey);
-            SAL_INFO("stoc.tdmanager", "\" in cache <" );
-#endif
-        }
-        pEntry->aVal = rValue;
-        toFront( pEntry );
-    }
-}
-//__________________________________________________________________________________________________
-template< class t_Key, class t_Val, class t_KeyHash, class t_KeyEqual >
-inline void LRU_Cache< t_Key, t_Val, t_KeyHash, t_KeyEqual >::clear()
-{
-    ::osl::MutexGuard aGuard( _aCacheMutex );
-    _aKey2Element.clear();
-    for ( sal_Int32 nPos = _nCachedElements; nPos--; )
-    {
-        _pBlock[nPos].aKey = t_Key();
-        _pBlock[nPos].aVal = t_Val();
-    }
-#ifdef __CACHE_DIAGNOSE
-    SAL_INFO("stoc.tdmanager", "> cleared cache <" );
-#endif
-}
-
-//==================================================================================================
-struct FctHashOUString : public ::std::unary_function< OUString const &, size_t >
-{
-    size_t operator()( OUString const & rKey ) const
-        { return (size_t)rKey.hashCode(); }
-};
-
-/** Template instance for OUString keys, Any values.<br>
-*/
-typedef LRU_Cache< OUString, ::com::sun::star::uno::Any,
-                   FctHashOUString, ::std::equal_to< OUString > >
-    LRU_CacheAnyByOUString;
-
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/tdmanager/tdmgr.cxx b/stoc/source/tdmanager/tdmgr.cxx
deleted file mode 100644
index d7242910ac0b..000000000000
--- a/stoc/source/tdmanager/tdmgr.cxx
+++ /dev/null
@@ -1,1132 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#include <osl/diagnose.h>
-#include <osl/mutex.hxx>
-#include "rtl/ustrbuf.hxx"
-#include <cppuhelper/factory.hxx>
-#include <cppuhelper/compbase5.hxx>
-#include <cppuhelper/implbase1.hxx>
-#include <cppuhelper/implementationentry.hxx>
-#include "tdmgr_common.hxx"
-#include "tdmgr_tdenumeration.hxx"
-#include "lrucache.hxx"
-
-#include <com/sun/star/lang/XServiceInfo.hpp>
-#include <com/sun/star/lang/XSingleServiceFactory.hpp>
-#include <com/sun/star/lang/XEventListener.hpp>
-#include <com/sun/star/lang/XTypeProvider.hpp>
-#include <com/sun/star/lang/XComponent.hpp>
-#include <com/sun/star/lang/XInitialization.hpp>
-#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
-#include <com/sun/star/container/XSet.hpp>
-#include <com/sun/star/container/XContentEnumerationAccess.hpp>
-#include <com/sun/star/reflection/XTypeDescription.hpp>
-#include <com/sun/star/reflection/XArrayTypeDescription.hpp>
-#include <com/sun/star/reflection/XIndirectTypeDescription.hpp>
-#include <com/sun/star/reflection/XInterfaceTypeDescription.hpp>
-#include "com/sun/star/reflection/XStructTypeDescription.hpp"
-#include <com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp>
-#include <com/sun/star/registry/XRegistryKey.hpp>
-#include "com/sun/star/uno/RuntimeException.hpp"
-
-#include <algorithm>
-#include <vector>
-
-using namespace std;
-using namespace cppu;
-using namespace osl;
-using namespace com::sun::star;
-using namespace com::sun::star::uno;
-using namespace com::sun::star::lang;
-using namespace com::sun::star::reflection;
-using namespace com::sun::star::container;
-using namespace com::sun::star::registry;
-
-
-static const sal_Int32 CACHE_SIZE = 512;
-
-#define SERVICENAME "com.sun.star.reflection.TypeDescriptionManager"
-#define IMPLNAME    "com.sun.star.comp.stoc.TypeDescriptionManager"
-
-namespace stoc_bootstrap
-{
-Sequence< OUString > SAL_CALL tdmgr_getSupportedServiceNames()
-{
-    Sequence< OUString > seqNames(1);
-    seqNames.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICENAME));
-    return seqNames;
-}
-
-OUString SAL_CALL tdmgr_getImplementationName()
-{
-    return OUString(RTL_CONSTASCII_USTRINGPARAM(IMPLNAME));
-}
-}
-
-namespace stoc_tdmgr
-{
-typedef vector< Reference< XHierarchicalNameAccess > > ProviderVector;
-
-class EnumerationImpl;
-class ManagerImpl;
-
-//==================================================================================================
-class EventListenerImpl : public ImplHelper1< XEventListener >
-{
-    ManagerImpl *       _pMgr;
-
-public:
-    EventListenerImpl( ManagerImpl * pMgr )
-        : _pMgr( pMgr )
-        {}
-    virtual ~EventListenerImpl();
-
-    // lifetime delegated to manager
-    virtual void SAL_CALL acquire() throw();
-    virtual void SAL_CALL release() throw();
-
-    // XEventListener
-    virtual void SAL_CALL disposing( const EventObject & rEvt ) throw(::com::sun::star::uno::RuntimeException);
-};
-
-EventListenerImpl::~EventListenerImpl() {}
-
-//==================================================================================================
-class ManagerImpl
-    : public WeakComponentImplHelper5< XServiceInfo,
-                                       XSet,
-                                       XHierarchicalNameAccess,
-                                       XTypeDescriptionEnumerationAccess,
-                                       XInitialization >
-{
-    friend class EnumerationImpl;
-    friend class EventListenerImpl;
-
-    Mutex                               _aComponentMutex;
-    Reference< XComponentContext >      _xContext;
-    EventListenerImpl                   _aEventListener;
-
-    // elements
-    sal_Bool                            _bCaching;
-    LRU_CacheAnyByOUString              _aElements;
-    // provider chain
-    ProviderVector                      _aProviders;
-
-    inline Any getSimpleType( const OUString & rName );
-
-    Reference< XTypeDescription > getInstantiatedStruct(OUString const & name);
-
-protected:
-    virtual void SAL_CALL disposing();
-
-public:
-    ManagerImpl( Reference< XComponentContext > const & xContext, sal_Int32 nCacheSize );
-    virtual ~ManagerImpl();
-
-    // XInitialization
-    virtual void SAL_CALL initialize( const Sequence< Any > & args ) throw (Exception, RuntimeException);
-
-    // XServiceInfo
-    virtual OUString SAL_CALL getImplementationName() throw(::com::sun::star::uno::RuntimeException);
-    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw(::com::sun::star::uno::RuntimeException);
-    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException);
-
-    // XElementAccess
-    virtual Type SAL_CALL getElementType() throw(::com::sun::star::uno::RuntimeException);
-    virtual sal_Bool SAL_CALL hasElements() throw(::com::sun::star::uno::RuntimeException);
-
-    // XEnumerationAccess
-    virtual Reference< XEnumeration > SAL_CALL createEnumeration() throw(::com::sun::star::uno::RuntimeException);
-
-    // XSet
-    virtual sal_Bool SAL_CALL has( const Any & rElement ) throw(::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL insert( const Any & rElement ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::ElementExistException, ::com::sun::star::uno::RuntimeException);
-    virtual void SAL_CALL remove( const Any & rElement ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::NoSuchElementException, ::com::sun::star::uno::RuntimeException);
-
-    // XHierarchicalNameAccess
-    virtual Any SAL_CALL getByHierarchicalName( const OUString & rName ) throw(::com::sun::star::container::NoSuchElementException, ::com::sun::star::uno::RuntimeException);
-    virtual sal_Bool SAL_CALL hasByHierarchicalName( const OUString & rName ) throw(::com::sun::star::uno::RuntimeException);
-
-    // XTypeDescriptionEnumerationAccess
-    virtual ::com::sun::star::uno::Reference<
-        ::com::sun::star::reflection::XTypeDescriptionEnumeration > SAL_CALL
-    createTypeDescriptionEnumeration(
-        const OUString& moduleName,
-        const ::com::sun::star::uno::Sequence<
-            ::com::sun::star::uno::TypeClass >& types,
-        ::com::sun::star::reflection::TypeDescriptionSearchDepth depth )
-            throw ( ::com::sun::star::reflection::NoSuchTypeNameException,
-                    ::com::sun::star::reflection::InvalidTypeNameException,
-                    ::com::sun::star::uno::RuntimeException );
-};
-
-//==================================================================================================
-class EnumerationImpl
-    : public WeakImplHelper1< XEnumeration >
-{
-    ManagerImpl *       _pMgr;
-    size_t              _nPos;
-
-public:
-    EnumerationImpl( ManagerImpl * pManager );
-    virtual ~EnumerationImpl();
-
-    // XEnumeration
-    virtual sal_Bool SAL_CALL hasMoreElements() throw(::com::sun::star::uno::RuntimeException);
-    virtual Any SAL_CALL nextElement() throw(::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
-};
-
-//##################################################################################################
-
-// lifetime delegated to manager
-//__________________________________________________________________________________________________
-void EventListenerImpl::acquire() throw()
-{
-    _pMgr->acquire();
-}
-//__________________________________________________________________________________________________
-void EventListenerImpl::release() throw()
-{
-    _pMgr->release();
-}
-
-// XEventListener
-//__________________________________________________________________________________________________
-void EventListenerImpl::disposing( const EventObject & rEvt )
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    _pMgr->remove( makeAny( rEvt.Source ) );
-}
-
-//##################################################################################################
-
-//__________________________________________________________________________________________________
-EnumerationImpl::EnumerationImpl( ManagerImpl * pManager )
-    : _pMgr( pManager )
-    , _nPos( 0 )
-{
-    _pMgr->acquire();
-}
-//__________________________________________________________________________________________________
-EnumerationImpl::~EnumerationImpl()
-{
-    _pMgr->release();
-}
-
-// XEnumeration
-//__________________________________________________________________________________________________
-sal_Bool EnumerationImpl::hasMoreElements()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    MutexGuard aGuard( _pMgr->_aComponentMutex );
-    return (_nPos < _pMgr->_aProviders.size());
-}
-//__________________________________________________________________________________________________
-Any EnumerationImpl::nextElement()
-    throw(::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
-{
-    MutexGuard aGuard( _pMgr->_aComponentMutex );
-    if (_nPos >= _pMgr->_aProviders.size())
-    {
-        throw NoSuchElementException(
-            OUString("there is no further element!"),
-            (XWeak *)(OWeakObject *)this );
-    }
-    return makeAny( _pMgr->_aProviders[_nPos++] );
-}
-
-//##################################################################################################
-
-//__________________________________________________________________________________________________
-ManagerImpl::ManagerImpl(
-    Reference< XComponentContext > const & xContext, sal_Int32 nCacheSize )
-    : WeakComponentImplHelper5<
-        XServiceInfo, XSet, XHierarchicalNameAccess,
-        XTypeDescriptionEnumerationAccess, XInitialization >( _aComponentMutex )
-    , _xContext( xContext )
-    , _aEventListener( this )
-    , _bCaching( sal_True )
-    , _aElements( nCacheSize )
-{}
-//__________________________________________________________________________________________________
-ManagerImpl::~ManagerImpl()
-{
-    OSL_ENSURE( _aProviders.empty(), "### still providers left!" );
-    OSL_TRACE( "> TypeDescriptionManager shut down. <" );
-}
-//__________________________________________________________________________________________________
-void ManagerImpl::disposing()
-{
-    // called on disposing the tdmgr instance (supposedly from context)
-    _bCaching = sal_False;
-    _aElements.clear();
-    _xContext.clear();
-    _aProviders.clear();
-}
-
-// XInitialization
-//__________________________________________________________________________________________________
-void ManagerImpl::initialize(
-    const Sequence< Any > & args )
-    throw (Exception, RuntimeException)
-{
-    // additional providers
-    Any const * pProviders = args.getConstArray();
-    for ( sal_Int32 nPos = 0; nPos < args.getLength(); ++nPos )
-    {
-        Reference< XHierarchicalNameAccess > xHA( pProviders[ nPos ], UNO_QUERY );
-        OSL_ENSURE( xHA.is(), "### no td provider!" );
-
-        if (xHA.is())
-        {
-            try
-            {
-                insert( makeAny( xHA ) );
-            }
-            catch (const IllegalArgumentException &)
-            {
-            }
-            catch (const ElementExistException &)
-            {
-            }
-        }
-    }
-}
-
-// XServiceInfo
-//__________________________________________________________________________________________________
-OUString ManagerImpl::getImplementationName()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return stoc_bootstrap::tdmgr_getImplementationName();
-}
-//__________________________________________________________________________________________________
-sal_Bool ManagerImpl::supportsService( const OUString & rServiceName )
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    const Sequence< OUString > & rSNL = getSupportedServiceNames();
-    const OUString * pArray = rSNL.getConstArray();
-    for ( sal_Int32 nPos = rSNL.getLength(); nPos--; )
-    {
-        if (pArray[nPos] == rServiceName)
-            return sal_True;
-    }
-    return sal_False;
-}
-//__________________________________________________________________________________________________
-Sequence< OUString > ManagerImpl::getSupportedServiceNames()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return stoc_bootstrap::tdmgr_getSupportedServiceNames();
-}
-
-// XElementAccess
-//__________________________________________________________________________________________________
-Type ManagerImpl::getElementType()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return ::getCppuType( (const Reference< XHierarchicalNameAccess > *)0 );
-}
-//__________________________________________________________________________________________________
-sal_Bool ManagerImpl::hasElements()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    MutexGuard aGuard( _aComponentMutex );
-    return (!_aProviders.empty());
-}
-
-// XEnumerationAccess
-//__________________________________________________________________________________________________
-Reference< XEnumeration > ManagerImpl::createEnumeration()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return new EnumerationImpl( this );
-}
-
-// XSet
-//__________________________________________________________________________________________________
-sal_Bool SAL_CALL ManagerImpl::has( const Any & rElement )
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    Reference< XHierarchicalNameAccess > xElem;
-    if (rElement >>= xElem)
-    {
-        MutexGuard aGuard( _aComponentMutex );
-        return (find( _aProviders.begin(), _aProviders.end(), xElem ) != _aProviders.end());
-    }
-    return sal_False;
-}
-
-//__________________________________________________________________________________________________
-void SAL_CALL ManagerImpl::insert( const Any & rElement )
-    throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::ElementExistException, ::com::sun::star::uno::RuntimeException)
-{
-    // Passing in a sequence of type providers instead of a single one bypasses
-    // the consistency checks; it is used during bootstrap:
-    bool doCheck = false;
-    css::uno::Sequence<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > provs;
-    if (!(rElement >>= provs)) {
-        css::uno::Reference< css::container::XHierarchicalNameAccess > prov;
-        if (!(rElement >>= prov)) {
-            throw css::lang::IllegalArgumentException(
-                "no type description provider (or sequence thereof)",
-                static_cast< cppu::OWeakObject * >(this), 0);
-        }
-        doCheck = true;
-        provs.realloc(1);
-        provs[0] = prov;
-    }
-
-    MutexGuard aGuard( _aComponentMutex );
-    ProviderVector newProvs(_aProviders);
-    for (sal_Int32 i = 0; i != provs.getLength(); ++i) {
-        Reference< XHierarchicalNameAccess > xElem(provs[i]);
-        if (!xElem.is()) {
-            throw css::lang::IllegalArgumentException(
-                "null type description provider",
-                static_cast< cppu::OWeakObject * >(this), 0);
-        }
-
-        if (doCheck) {
-            if (find( newProvs.begin(), newProvs.end(), xElem ) != newProvs.end())
-            {
-                throw ElementExistException(
-                    OUString("provider already inserted!"),
-                    (XWeak *)(OWeakObject *)this );
-            }
-
-            // check whether all types are compatible, if possible:
-            Reference<reflection::XTypeDescriptionEnumerationAccess> xTDEnumAccess(
-                xElem, UNO_QUERY );
-            OSL_ENSURE( xTDEnumAccess.is(),
-                        "### providers ought to implement "
-                        "reflection::XTypeDescriptionEnumerationAccess!" );
-            if (xTDEnumAccess.is())
-            {
-                try
-                {
-                    TypeClass ar [] = {
-                        TypeClass_ENUM, TypeClass_TYPEDEF, TypeClass_SEQUENCE,
-                        TypeClass_STRUCT, TypeClass_EXCEPTION,
-                        /* TypeClass_UNION, TypeClass_ARRAY not supported */
-                        TypeClass_INTERFACE,
-                        TypeClass_SERVICE,
-                        TypeClass_INTERFACE_METHOD, TypeClass_INTERFACE_ATTRIBUTE,
-                        TypeClass_PROPERTY, TypeClass_CONSTANT, TypeClass_CONSTANTS,
-                        TypeClass_SINGLETON
-                    };
-                    Reference<reflection::XTypeDescriptionEnumeration> xTDEnum(
-                        xTDEnumAccess->createTypeDescriptionEnumeration(
-                            OUString() /* all modules */,
-                            Sequence<TypeClass>( ar, ARLEN(ar) ),
-                            reflection::TypeDescriptionSearchDepth_INFINITE ) );
-
-                    while (xTDEnum->hasMoreElements())
-                    {
-                        Reference<reflection::XTypeDescription> xNewTD;
-                        try
-                        {
-                            xNewTD = xTDEnum->nextTypeDescription();
-                        }
-                        catch (const container::NoSuchElementException & exc)
-                        {
-                            throw lang::IllegalArgumentException(
-                                "NoSuchElementException occurred: " +
-                                exc.Message, static_cast<OWeakObject *>(this),
-                                -1 /* unknown */ );
-                        }
-
-                        try
-                        {
-                            OUString newName( xNewTD->getName() );
-                            Reference<reflection::XTypeDescription> xExistingTD(
-                                getByHierarchicalName( newName ), UNO_QUERY );
-                            OSL_ASSERT( xExistingTD.is() );
-                            // existing, check whether compatible:
-                            if (xExistingTD.is())
-                            {
-                                try
-                                {
-                                    check( xNewTD, xExistingTD );
-                                }
-                                catch (const IncompatibleTypeException & exc)
-                                {
-                                    throw lang::IllegalArgumentException(
-                                        "Rejecting types due to "
-                                              "incompatibility!  " + exc.m_cause,
-                                        static_cast<OWeakObject *>(this), 0 );
-                                }
-                            }
-                        }
-                        catch (const container::NoSuchElementException &)
-                        {
-                            // type not in: ok
-                        }
-                    }
-                }
-                catch (const reflection::NoSuchTypeNameException & exc)
-                {
-                    throw lang::IllegalArgumentException(
-                        "NoSuchTypeNameException occurred: " + exc.Message,
-                        static_cast<OWeakObject *>(this), -1 /* unknown */ );
-            }
-                catch (const reflection::InvalidTypeNameException & exc)
-                {
-                    throw lang::IllegalArgumentException(
-                        "InvalidTypeNameException occurred: " + exc.Message,
-                        static_cast<OWeakObject *>(this), -1 /* unknown */ );
-                }
-            }
-        }
-        newProvs.push_back( xElem );
-    }
-
-    _aProviders = newProvs;
-    for (sal_Int32 i = 0; i != provs.getLength(); ++i) {
-        Reference< XComponent > xComp( provs[i], UNO_QUERY );
-        if (xComp.is())
-            xComp->addEventListener( &_aEventListener );
-    }
-}
-//__________________________________________________________________________________________________
-void SAL_CALL ManagerImpl::remove( const Any & rElement )
-    throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::NoSuchElementException, ::com::sun::star::uno::RuntimeException)
-{
-    if (!rBHelper.bDisposed && !rBHelper.bInDispose)
-    {
-        Reference< XHierarchicalNameAccess > xElem;
-        if (! (rElement >>= xElem))
-        {
-            throw IllegalArgumentException(
-                OUString("no type description provider given!"),
-                (XWeak *)(OWeakObject *)this, 0 );
-        }
-
-        MutexGuard aGuard( _aComponentMutex );
-        ProviderVector::iterator iFind( find( _aProviders.begin(), _aProviders.end(), xElem ) );
-        if (iFind == _aProviders.end())
-        {
-            throw NoSuchElementException(
-                OUString("provider not found!"),
-                (XWeak *)(OWeakObject *)this );
-        }
-        _aProviders.erase( iFind );
-    }
-
-    Reference< XComponent > xComp;
-    if (rElement >>= xComp)
-        xComp->removeEventListener( &_aEventListener );
-}
-
-// XTypeDescriptionEnumerationAccess
-//__________________________________________________________________________________________________
-// virtual
-Reference< XTypeDescriptionEnumeration > SAL_CALL
-ManagerImpl::createTypeDescriptionEnumeration(
-        const OUString & moduleName,
-        const Sequence< TypeClass > & types,
-        TypeDescriptionSearchDepth depth )
-    throw ( NoSuchTypeNameException,
-            InvalidTypeNameException,
-            RuntimeException )
-{
-    MutexGuard aGuard( _aComponentMutex );
-
-    TDEnumerationAccessStack aStack;
-    ProviderVector::const_iterator it = _aProviders.begin();
-    const ProviderVector::const_iterator end = _aProviders.end();
-    while ( it != end )
-    {
-        Reference< XTypeDescriptionEnumerationAccess >xEnumAccess(
-            (*it), UNO_QUERY );
-        OSL_ENSURE( xEnumAccess.is(),
-                    "### no XTypeDescriptionEnumerationAccess!" );
-        if ( xEnumAccess.is() )
-            aStack.push( xEnumAccess );
-
-        ++it;
-    }
-
-    return Reference< XTypeDescriptionEnumeration >(
-        new TypeDescriptionEnumerationImpl( moduleName,
-                                            types,
-                                            depth,
-                                            aStack ) );
-}
-
-
-//##################################################################################################
-//##################################################################################################
-//##################################################################################################
-
-
-//==================================================================================================
-class SimpleTypeDescriptionImpl
-    : public WeakImplHelper1< XTypeDescription >
-{
-    TypeClass _eTC;
-    OUString  _aName;
-
-public:
-    SimpleTypeDescriptionImpl( TypeClass eTC, const OUString & rName )
-        : _eTC( eTC )
-        , _aName( rName )
-        {}
-
-    // XTypeDescription
-    virtual TypeClass SAL_CALL getTypeClass() throw(::com::sun::star::uno::RuntimeException);
-    virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException);
-};
-
-// XTypeDescription
-//__________________________________________________________________________________________________
-TypeClass SimpleTypeDescriptionImpl::getTypeClass()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return _eTC;
-}
-//__________________________________________________________________________________________________
-OUString SimpleTypeDescriptionImpl::getName()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return _aName;
-}
-
-//==================================================================================================
-class SequenceTypeDescriptionImpl
-    : public WeakImplHelper1< XIndirectTypeDescription >
-{
-    Reference< XTypeDescription > _xElementTD;
-
-public:
-    SequenceTypeDescriptionImpl( const Reference< XTypeDescription > & xElementTD )
-        : _xElementTD( xElementTD )
-        {}
-
-    // XTypeDescription
-    virtual TypeClass SAL_CALL getTypeClass() throw(::com::sun::star::uno::RuntimeException);
-    virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException);
-
-    // XIndirectTypeDescription
-    virtual Reference< XTypeDescription > SAL_CALL getReferencedType() throw(::com::sun::star::uno::RuntimeException);
-};
-
-// XTypeDescription
-//__________________________________________________________________________________________________
-TypeClass SequenceTypeDescriptionImpl::getTypeClass()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return TypeClass_SEQUENCE;
-}
-//__________________________________________________________________________________________________
-OUString SequenceTypeDescriptionImpl::getName()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return (OUString("[]") + _xElementTD->getName());
-}
-
-// XIndirectTypeDescription
-//__________________________________________________________________________________________________
-Reference< XTypeDescription > SequenceTypeDescriptionImpl::getReferencedType()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return _xElementTD;
-}
-
-//==================================================================================================
-class ArrayTypeDescriptionImpl
-    : public WeakImplHelper1< XArrayTypeDescription >
-{
-    Reference< XTypeDescription > _xElementTD;
-    Mutex                         _aDimensionMutex;
-    sal_Int32                     _nDimensions;
-    Sequence< sal_Int32 >         _seqDimensions;
-    OUString                      _sDimensions;
-
-    void initDimensions(const OUString& rSDimensions);
-public:
-    ArrayTypeDescriptionImpl( const Reference< XTypeDescription > & xElementTD,
-                              sal_Int32 nDimensions, const OUString& rSDimensions )
-        : _xElementTD( xElementTD )
-        , _nDimensions( nDimensions )
-        , _seqDimensions( Sequence< sal_Int32 >(nDimensions) )
-        , _sDimensions( rSDimensions )
-        {
-            initDimensions( rSDimensions );
-        }
-    virtual ~ArrayTypeDescriptionImpl() {}
-
-    // XTypeDescription
-    virtual TypeClass SAL_CALL getTypeClass() throw(::com::sun::star::uno::RuntimeException);
-    virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException);
-
-    // XArrayTypeDescription
-    virtual Reference< XTypeDescription > SAL_CALL getType() throw(::com::sun::star::uno::RuntimeException);
-    virtual sal_Int32 SAL_CALL getNumberOfDimensions() throw(::com::sun::star::uno::RuntimeException);
-    virtual Sequence< sal_Int32 > SAL_CALL getDimensions() throw(::com::sun::star::uno::RuntimeException);
-};
-//__________________________________________________________________________________________________
-static sal_Int32 unicodeToInteger( sal_Int8 base, const sal_Unicode *s )
-{
-    sal_Int32    r = 0;
-    sal_Int32    negative = 0;
-
-    if (*s == '-')
-       {
-        negative = 1;
-          s++;
-       }
-       if (base == 8 && *s == '0')
-        s++;
-       else if (base == 16 && *s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))
-        s += 2;
-
-       for (; *s; s++)
-       {
-           if (*s <= '9' && *s >= '0')
-            r = (r * base) + (*s - '0');
-          else if (base > 10 && *s <= 'f' && *s >= 'a')
-            r = (r * base) + (*s - 'a' + 10);
-          else if (base > 10 && *s <= 'F' && *s >= 'A')
-            r = (r * base) + (*s - 'A' + 10);
-           else
-            break;
-    }
-       if (negative) r *= -1;
-    return r;
-}
-//__________________________________________________________________________________________________
-void ArrayTypeDescriptionImpl::initDimensions(const OUString& rSDimensions)
-{
-    MutexGuard aGuard( _aDimensionMutex );
-
-    sal_Int32 *  pDimensions = _seqDimensions.getArray();
-    OUString tmp(rSDimensions);
-    sal_Unicode* p = (sal_Unicode*)tmp.getStr()+1;
-    sal_Unicode* pOffset = p;
-    sal_Int32 len = tmp.getLength() - 1 ;
-    sal_Int32 i = 0;
-
-    while ( len > 0)
-    {
-        pOffset++;
-        if (*pOffset == ']')
-        {
-            *pOffset = '\0';
-            pOffset += 2;
-            len -= 3;
-            pDimensions[i++] = unicodeToInteger(10, p);
-            p = pOffset;
-        } else
-            len--;
-    }
-}
-
-// XTypeDescription
-//__________________________________________________________________________________________________
-TypeClass ArrayTypeDescriptionImpl::getTypeClass()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return TypeClass_ARRAY;
-}
-//__________________________________________________________________________________________________
-OUString ArrayTypeDescriptionImpl::getName()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return (_xElementTD->getName() + _sDimensions);
-}
-
-// XArrayTypeDescription
-//__________________________________________________________________________________________________
-Reference< XTypeDescription > ArrayTypeDescriptionImpl::getType()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return _xElementTD;
-}
-
-//__________________________________________________________________________________________________
-sal_Int32 ArrayTypeDescriptionImpl::getNumberOfDimensions()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return _nDimensions;
-}
-
-//__________________________________________________________________________________________________
-Sequence< sal_Int32 > ArrayTypeDescriptionImpl::getDimensions()
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    return _seqDimensions;
-}
-
-//##################################################################################################
-//##################################################################################################
-//##################################################################################################
-
-
-//__________________________________________________________________________________________________
-inline Any ManagerImpl::getSimpleType( const OUString & rName )
-{
-    Any aRet;
-
-    if ( rName == "string" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_STRING, rName ) );
-    else if ( rName == "long" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_LONG, rName ) );
-    else if ( rName == "unsigned long" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_UNSIGNED_LONG, rName ) );
-    else if ( rName == "boolean" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_BOOLEAN, rName ) );
-    else if ( rName == "char" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_CHAR, rName ) );
-    else if ( rName == "byte" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_BYTE, rName ) );
-    else if ( rName == "short" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_SHORT, rName ) );
-    else if ( rName == "unsigned short" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_UNSIGNED_SHORT, rName ) );
-    else if ( rName == "hyper" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_HYPER, rName ) );
-    else if ( rName == "unsigned hyper" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_UNSIGNED_HYPER, rName ) );
-    else if ( rName == "float" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_FLOAT, rName ) );
-    else if ( rName == "double" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_DOUBLE, rName ) );
-    else if ( rName == "any" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_ANY, rName ) );
-    else if ( rName == "void" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_VOID, rName ) );
-    else if ( rName == "type" )
-        aRet <<= Reference< XTypeDescription >( new SimpleTypeDescriptionImpl( TypeClass_TYPE, rName ) );
-
-    return aRet;
-}
-
-namespace {
-
-Reference< XTypeDescription > resolveTypedefs(
-    Reference< XTypeDescription > const & type)
-{
-    Reference< XTypeDescription > resolved(type);
-    while (resolved->getTypeClass() == TypeClass_TYPEDEF) {
-        resolved = Reference< XIndirectTypeDescription >(
-            type, UNO_QUERY_THROW)->getReferencedType();
-    }
-    return resolved;
-}
-
-bool isNonVoidNonExceptionType(Reference< XTypeDescription > const & type) {
-    switch (type->getTypeClass()) {
-    case TypeClass_BOOLEAN:
-    case TypeClass_BYTE:
-    case TypeClass_SHORT:
-    case TypeClass_UNSIGNED_SHORT:
-    case TypeClass_LONG:
-    case TypeClass_UNSIGNED_LONG:
-    case TypeClass_HYPER:
-    case TypeClass_UNSIGNED_HYPER:
-    case TypeClass_FLOAT:
-    case TypeClass_DOUBLE:
-    case TypeClass_CHAR:
-    case TypeClass_STRING:
-    case TypeClass_TYPE:
-    case TypeClass_ANY:
-    case TypeClass_SEQUENCE:
-    case TypeClass_ENUM:
-    case TypeClass_STRUCT:
-    case TypeClass_INTERFACE:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-class InstantiatedStruct: public WeakImplHelper1< XStructTypeDescription > {
-public:
-    InstantiatedStruct(
-        Reference< XStructTypeDescription > const & structType,
-        std::vector< Reference< XTypeDescription > > const & arguments);
-
-    virtual TypeClass SAL_CALL getTypeClass() throw (RuntimeException)
-    { return TypeClass_STRUCT; }
-
-    virtual OUString SAL_CALL getName() throw (RuntimeException);
-
-    virtual Reference< XTypeDescription > SAL_CALL getBaseType()
-        throw (RuntimeException)
-    { return m_struct->getBaseType(); }
-
-    virtual Sequence< Reference< XTypeDescription > > SAL_CALL getMemberTypes()
-        throw (RuntimeException);
-
-    virtual Sequence< OUString > SAL_CALL getMemberNames()
-        throw (RuntimeException)
-    { return m_struct->getMemberNames(); }
-
-    virtual Sequence< OUString > SAL_CALL getTypeParameters()
-        throw (RuntimeException)
-    { return Sequence< OUString >(); }
-
-    virtual Sequence< Reference< XTypeDescription > > SAL_CALL
-    getTypeArguments() throw (RuntimeException)
-    { return m_arguments; }
-
-private:
-    Reference< XStructTypeDescription > m_struct;
-    Sequence< Reference< XTypeDescription > > m_arguments;
-};
-
-InstantiatedStruct::InstantiatedStruct(
-    Reference< XStructTypeDescription > const & structType,
-    std::vector< Reference< XTypeDescription > > const & arguments):
-    m_struct(structType),
-    m_arguments(static_cast< sal_Int32 >(arguments.size()))
-{
-    for (std::vector< Reference< XTypeDescription > >::size_type i = 0;
-         i < arguments.size(); ++i)
-    {
-        m_arguments[static_cast< sal_Int32 >(i)] = arguments[i];
-    }
-}
-
-OUString InstantiatedStruct::getName() throw (RuntimeException) {
-    OUStringBuffer buf(m_struct->getName());
-    buf.append(static_cast< sal_Unicode >('<'));
-    for (sal_Int32 i = 0; i < m_arguments.getLength(); ++i) {
-        if (i != 0) {
-            buf.append(static_cast< sal_Unicode >(','));
-        }
-        buf.append(m_arguments[i]->getName());
-    }
-    buf.append(static_cast< sal_Unicode >('>'));
-    return buf.makeStringAndClear();
-}
-
-Sequence< Reference< XTypeDescription > > InstantiatedStruct::getMemberTypes()
-    throw (RuntimeException)
-{
-    Sequence< Reference< XTypeDescription > > types(m_struct->getMemberTypes());
-    for (sal_Int32 i = 0; i < types.getLength(); ++i) {
-        if (types[i]->getTypeClass() == TypeClass_UNKNOWN) {
-            Sequence< OUString > parameters(m_struct->getTypeParameters());
-            OSL_ASSERT(parameters.getLength() == m_arguments.getLength());
-            for (sal_Int32 j = 0; j < parameters.getLength(); ++j) {
-                if (parameters[j] == types[i]->getName()) {
-                    types[i] = m_arguments[j];
-                    break;
-                }
-            }
-        }
-    }
-    return types;
-}
-
-}
-
-Reference< XTypeDescription > ManagerImpl::getInstantiatedStruct(
-    OUString const & name)
-{
-    sal_Int32 i = name.indexOf('<');
-    OSL_ASSERT(i >= 0);
-    Reference< XStructTypeDescription > structType(
-        getByHierarchicalName(name.copy(0, i)), UNO_QUERY);
-    std::vector< Reference< XTypeDescription > > args;
-    bool good = structType.is();
-    if (good) {
-        do {
-            ++i; // skip '<' or ','
-            sal_Int32 j = i;
-            for (sal_Int32 level = 0; j != name.getLength(); ++j) {
-                sal_Unicode c = name[j];
-                if (c == ',') {
-                    if (level == 0) {
-                        break;
-                    }
-                } else if (c == '<') {
-                    ++level;
-                } else if (c == '>') {
-                    if (level == 0) {
-                        break;
-                    }
-                    --level;
-                }
-            }
-            if (j != name.getLength()) {
-                Reference< XTypeDescription > type(
-                    getByHierarchicalName(name.copy(i, j - i)), UNO_QUERY);
-                if (isNonVoidNonExceptionType(resolveTypedefs(type))) {
-                    args.push_back(type);
-                } else {
-                    good = false;
-                    break;
-                }
-            }
-            i = j;
-        } while (i != name.getLength() && name[i] != '>');
-        good = good && i == name.getLength() - 1
-            && name[i] == '>' && !args.empty();
-    }
-    // args.size() cannot exceed SAL_MAX_INT32, as each argument consumes at
-    // least one position within an OUString (which is no longer than
-    // SAL_MAX_INT32):
-    if (!good
-        || (args.size()
-            != sal::static_int_cast< sal_uInt32 >(
-                structType->getTypeParameters().getLength())))
-    {
-        throw NoSuchElementException(name, static_cast< OWeakObject * >(this));
-    }
-    return new InstantiatedStruct(structType, args);
-}
-
-// XHierarchicalNameAccess
-//__________________________________________________________________________________________________
-Any ManagerImpl::getByHierarchicalName( const OUString & rName )
-    throw(::com::sun::star::container::NoSuchElementException, ::com::sun::star::uno::RuntimeException)
-{
-    Any aRet;
-    if (_bCaching)
-        aRet = _aElements.getValue( rName );
-    if (!rName.isEmpty() && !aRet.hasValue())
-    {
-        sal_Int32 nIndex;
-        if (rName[0] == '[') // test for sequence
-        {
-            Reference< XTypeDescription > xElemType(
-                getByHierarchicalName( rName.copy( 2 ) ),
-                UNO_QUERY_THROW );
-            aRet <<= Reference< XTypeDescription >(
-                new SequenceTypeDescriptionImpl( xElemType ) );
-        }
-        else if (rName[rName.getLength()-1] == ']') // test for array
-        {
-            sal_Int32 nIndex2 = 0, nTokens = 0;
-            do { rName.getToken( 0, '[', nIndex2 ); nTokens++; } while( nIndex2 != -1 );
-            sal_Int32 nDims = nTokens - 1;
-            sal_Int32 dimOffset = rName.indexOf('[');
-            Reference< XTypeDescription > xElemType(
-                getByHierarchicalName( rName.copy( 0, dimOffset ) ),
-                UNO_QUERY_THROW );
-            aRet <<= Reference< XTypeDescription >(
-                new ArrayTypeDescriptionImpl(
-                    xElemType, nDims, rName.copy(dimOffset) ) );
-        }
-        // test for interface member names:
-        else if ((nIndex = rName.indexOf( ':' )) >= 0)
-        {
-            Reference< XInterfaceTypeDescription > xIfaceTD(
-                getByHierarchicalName( rName.copy( 0, nIndex ) ),
-                UNO_QUERY_THROW );
-            const Sequence< Reference< XInterfaceMemberTypeDescription > > &
-                rMembers = xIfaceTD->getMembers();
-            const Reference< XInterfaceMemberTypeDescription > * pMembers =
-                rMembers.getConstArray();
-
-            for ( sal_Int32 nPos = rMembers.getLength(); nPos--; )
-            {
-                if (rName == pMembers[nPos]->getName())
-                {
-                    aRet <<= Reference< XTypeDescription >(
-                        pMembers[nPos], UNO_QUERY_THROW );
-                    break;
-                }
-            }
-            if (! aRet.hasValue())
-            {
-                // member not found:
-                throw NoSuchElementException(
-                    rName, static_cast< OWeakObject * >(this) );
-            }
-        }
-        // test for instantiated polymorphic struct types:
-        else if (rName.indexOf('<') >= 0)
-        {
-            aRet <<= getInstantiatedStruct(rName);
-        }
-        else if (rName.indexOf( '.' ) < 0) // test for simple/ build in types
-        {
-            aRet = getSimpleType( rName );
-        }
-
-        if (! aRet.hasValue())
-        {
-            // last, try callback chain
-            for ( ProviderVector::const_iterator iPos( _aProviders.begin() );
-                  iPos != _aProviders.end(); ++iPos )
-            {
-                if ( (*iPos)->hasByHierarchicalName( rName ) )
-                {
-                    aRet = (*iPos)->getByHierarchicalName( rName );
-                    break;
-                }
-            }
-        }
-
-        // update cache
-        if (_bCaching && aRet.hasValue())
-            _aElements.setValue( rName, aRet );
-    }
-
-    if (! aRet.hasValue())
-    {
-        throw NoSuchElementException(
-            rName, static_cast< OWeakObject * >(this) );
-    }
-    return aRet;
-}
-//__________________________________________________________________________________________________
-sal_Bool ManagerImpl::hasByHierarchicalName( const OUString & rName )
-    throw(::com::sun::star::uno::RuntimeException)
-{
-    try
-    {
-        return getByHierarchicalName( rName ).hasValue();
-    }
-    catch (const NoSuchElementException &)
-    {
-    }
-    return sal_False;
-}
-}
-
-namespace stoc_bootstrap
-{
-//==================================================================================================
-Reference< XInterface > SAL_CALL ManagerImpl_create(
-    Reference< XComponentContext > const & xContext )
-    SAL_THROW( (::com::sun::star::uno::Exception) )
-{
-    sal_Int32 nCacheSize = CACHE_SIZE;
-    if (xContext.is()) {
-        xContext->getValueByName(
-            OUString(
-                RTL_CONSTASCII_USTRINGPARAM(
-                    "/implementations/" IMPLNAME "/CacheSize"))) >>=
-            nCacheSize;
-    }
-
-    return Reference< XInterface >( *new stoc_tdmgr::ManagerImpl( xContext, nCacheSize ) );
-}
-
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/tdmanager/tdmgr_check.cxx b/stoc/source/tdmanager/tdmgr_check.cxx
deleted file mode 100644
index 2ffb80a32c97..000000000000
--- a/stoc/source/tdmanager/tdmgr_check.cxx
+++ /dev/null
@@ -1,546 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-
-#include "tdmgr_common.hxx"
-#include "rtl/ustrbuf.hxx"
-#include "typelib/typedescription.h"
-#include "com/sun/star/beans/PropertyAttribute.hpp"
-#include "com/sun/star/reflection/XConstantsTypeDescription.hpp"
-#include "com/sun/star/reflection/XIndirectTypeDescription.hpp"
-#include "com/sun/star/reflection/XEnumTypeDescription.hpp"
-#include "com/sun/star/reflection/XStructTypeDescription.hpp"
-#include "com/sun/star/reflection/XInterfaceTypeDescription2.hpp"
-#include "com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp"
-#include "com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp"
-#include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
-#include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
-
-
-using namespace ::com::sun::star;
-using namespace ::com::sun::star::uno;
-using namespace ::stoc_tdmgr;
-
-namespace {
-
-OUString getTypeClassName( TypeClass tc )
-{
-    typelib_EnumTypeDescription * typeDescr = 0;
-    OUString name = "com.sun.star.uno.TypeClass";
-    typelib_typedescription_getByName(
-        reinterpret_cast<typelib_TypeDescription **>(&typeDescr), name.pData );
-    OSL_ASSERT( typeDescr != 0 );
-    if (typeDescr == 0)
-        return "Cannot get type description of " + name;
-    typelib_typedescription_complete(
-        reinterpret_cast<typelib_TypeDescription **>(&typeDescr) );
-
-    sal_Int32 const * pValues = typeDescr->pEnumValues;
-    sal_Int32 nPos = typeDescr->nEnumValues;
-    while (nPos--)
-    {
-        if (pValues[ nPos ] == (sal_Int32) tc)
-            break;
-    }
-    if (nPos >= 0)
-        name = typeDescr->ppEnumNames[ nPos ];
-    else
-        name = "unknown TypeClass value: " +
-            OUString::valueOf( (sal_Int32) tc );
-
-    typelib_typedescription_release(
-        reinterpret_cast<typelib_TypeDescription *>(typeDescr) );
-    return name;
-}
-
-OUString getPropertyFlagsAsString( sal_Int16 attributes )
-{
-    OUStringBuffer buf;
-    if ((attributes & beans::PropertyAttribute::MAYBEVOID) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEVOID, ") );
-    if ((attributes & beans::PropertyAttribute::BOUND) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("BOUND, ") );
-    if ((attributes & beans::PropertyAttribute::CONSTRAINED) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("CONSTRAINED, ") );
-    if ((attributes & beans::PropertyAttribute::TRANSIENT) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("TRANSIENT, ") );
-    if ((attributes & beans::PropertyAttribute::READONLY) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("READONLY, ") );
-    if ((attributes & beans::PropertyAttribute::MAYBEAMBIGUOUS) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEAMBIGUOUS, ") );
-    if ((attributes & beans::PropertyAttribute::MAYBEDEFAULT) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("MAYBEDEFAULT, ") );
-    if ((attributes & beans::PropertyAttribute::REMOVABLE) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("REMOVABLE, ") );
-    if ((attributes & beans::PropertyAttribute::OPTIONAL) != 0)
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("OPTIONAL") );
-    else if (buf.getLength() > 0)
-        buf.setLength( buf.getLength() - 2 ); // truncate ", "
-    return buf.makeStringAndClear();
-}
-
-void typeError( OUString const & msg, OUString const & context )
-{
-    OUStringBuffer buf;
-    if (!context.isEmpty()) {
-        buf.append( static_cast<sal_Unicode>('[') );
-        buf.append( context );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("] ") );
-    }
-    buf.append( msg );
-    throw IncompatibleTypeException( buf.makeStringAndClear() );
-}
-
-template<typename T>
-void checkSeq( Sequence< Reference<T> > const & newTypes,
-            Sequence< Reference<T> > const & existingTypes,
-            OUString const & context,
-            bool optionalMode = false )
-{
-    sal_Int32 len = newTypes.getLength();
-    if (len != existingTypes.getLength())
-    {
-        if (!optionalMode || len < newTypes.getLength())
-            typeError( "Different number of types!", context );
-        len = existingTypes.getLength();
-    }
-
-    Reference<T> const * pNewTypes = newTypes.getConstArray();
-    Reference<T> const * pExistingTypes = existingTypes.getConstArray();
-    for ( sal_Int32 pos = 0; pos < len; ++pos )
-    {
-        OUStringBuffer buf;
-        buf.append( context );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", position ") );
-        buf.append( pos );
-        check( pNewTypes[pos].get(), pExistingTypes[pos].get(),
-               buf.makeStringAndClear() );
-    }
-}
-
-void checkEnum(
-    Reference<reflection::XEnumTypeDescription> const & xNewTD,
-    Reference<reflection::XEnumTypeDescription> const & xExistingTD )
-{
-    if (xNewTD->getEnumNames() != xExistingTD->getEnumNames())
-        typeError( "ENUM names don't match!", xNewTD->getName() );
-    if (xNewTD->getEnumValues() != xExistingTD->getEnumValues())
-        typeError( "ENUM values don't match!", xNewTD->getName() );
-}
-
-void checkStruct(
-    Reference<reflection::XCompoundTypeDescription> const & xNewTD,
-    Reference<reflection::XCompoundTypeDescription> const & xExistingTD )
-{
-    check( xNewTD->getBaseType(), xExistingTD->getBaseType(),
-           xNewTD->getName() + ", base type" );
-    checkSeq( xNewTD->getMemberTypes(), xExistingTD->getMemberTypes(),
-              xNewTD->getName() + ", member types" );
-
-    if (xNewTD->getMemberNames() != xExistingTD->getMemberNames())
-        typeError( "Different member names!", xNewTD->getName() );
-
-    if (xNewTD->getTypeClass() == TypeClass_STRUCT)
-    {
-        Reference<reflection::XStructTypeDescription> xNewStructTD(
-            xNewTD, UNO_QUERY );
-        Reference<reflection::XStructTypeDescription> xExistingStructTD(
-            xExistingTD, UNO_QUERY );
-        if (xNewStructTD.is() && xExistingStructTD.is())
-        {
-            if (xNewStructTD->getTypeParameters() !=
-                xExistingStructTD->getTypeParameters())
-                typeError( "Different type parameters of instantiated "
-                           "polymorphic STRUCT!", xNewTD->getName() );
-            checkSeq( xNewStructTD->getTypeArguments(),
-                      xExistingStructTD->getTypeArguments(),
-                      xNewTD->getName() + ", argument types" );
-        }
-        else if (xNewStructTD.is() || xExistingStructTD.is())
-            typeError( "Mixing polymorphic STRUCT types "
-                       "with non-polymorphic!", xNewTD->getName() );
-    }
-}
-
-void checkInterface(
-    Reference<reflection::XInterfaceTypeDescription2> const & xNewTD,
-    Reference<reflection::XInterfaceTypeDescription2> const & xExistingTD )
-{
-    checkSeq( xNewTD->getBaseTypes(), xExistingTD->getBaseTypes(),
-              xNewTD->getName() + ", base types" );
-    checkSeq(xNewTD->getOptionalBaseTypes(),xExistingTD->getOptionalBaseTypes(),
-             xNewTD->getName() + ", optional base types" );
-    checkSeq( xNewTD->getMembers(), xExistingTD->getMembers(),
-              xNewTD->getName() + ", members" );
-}
-
-void checkRestParam( Reference<reflection::XParameter> const & xNewParam,
-                     Reference<reflection::XParameter> const & xExistingParam,
-                     OUString const & context )
-{
-    if (xNewParam->isRestParameter() != xExistingParam->isRestParameter())
-        typeError( "Different ... parameters specified!", context );
-}
-
-void checkRestParam(
-    SAL_UNUSED_PARAMETER Reference<reflection::XMethodParameter> const &,
-    SAL_UNUSED_PARAMETER Reference<reflection::XMethodParameter> const &,
-    SAL_UNUSED_PARAMETER OUString const & )
-{}
-
-template<typename T>
-void checkParameters( Sequence< Reference<T> > const & newParams,
-                      Sequence< Reference<T> > const & existingParams,
-                      OUString const & context_ )
-{
-    sal_Int32 len = newParams.getLength();
-    if (len != existingParams.getLength())
-        typeError( "Different number of parameters!", context_ );
-    Reference<T> const * pNewParams = newParams.getConstArray();
-    Reference<T> const * pExistingParams = existingParams.getConstArray();
-    for ( sal_Int32 pos = 0; pos < len; ++pos )
-    {
-        Reference<T> const & xNewParam = pNewParams[pos];
-        Reference<T> const & xExistingParam = pExistingParams[pos];
-
-        OUStringBuffer buf;
-        buf.append( context_ );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", parameter ") );
-        buf.append( pos );
-        OSL_ASSERT( pos == xNewParam->getPosition() &&
-                    pos == xExistingParam->getPosition() );
-        OUString context( buf.makeStringAndClear() );
-
-        if (xNewParam->getName() != xExistingParam->getName())
-        {
-            buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("Name differs: ") );
-            buf.append( xNewParam->getName() );
-            buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", ") );
-            buf.append( xExistingParam->getName() );
-            typeError( buf.makeStringAndClear(), context );
-        }
-        check( xNewParam->getType(), xExistingParam->getType(), context );
-
-        if (xNewParam->isIn() != xExistingParam->isIn())
-            typeError( "IN attribute differs!", context );
-        if (xNewParam->isOut() != xExistingParam->isOut())
-            typeError( "OUT attribute differs!", context );
-        checkRestParam( xNewParam, xExistingParam, context );
-    }
-}
-
-static void checkMethod(
-    Reference<reflection::XInterfaceMethodTypeDescription> const & xNewTD,
-    Reference<reflection::XInterfaceMethodTypeDescription> const & xExistingTD )
-{
-    check( xNewTD->getReturnType(), xExistingTD->getReturnType(),
-           xNewTD->getName() );
-
-    if (xNewTD->isOneway() != xExistingTD->isOneway())
-        typeError( "Methods have differing OneWay attribute!",
-                   xNewTD->getName() );
-
-    checkParameters( xNewTD->getParameters(), xExistingTD->getParameters(),
-                     xNewTD->getName() );
-
-    checkSeq( xNewTD->getExceptions(), xExistingTD->getExceptions(),
-              xNewTD->getName() + ", declared exceptions" );
-}
-
-void checkAttribute(
-    Reference<reflection::XInterfaceAttributeTypeDescription2> const & xNewTD,
-    Reference<reflection::XInterfaceAttributeTypeDescription2>
-    const & xExistingTD )
-{
-    if (xNewTD->isReadOnly() != xExistingTD->isReadOnly())
-        typeError( "ReadOnly attribute differs!", xNewTD->getName() );
-
-    check( xNewTD->getType(), xExistingTD->getType(),
-           xNewTD->getName() + ", attribute type" );
-
-    if (xNewTD->isBound() != xExistingTD->isBound())
-        typeError( "Bound attribute differs!", xNewTD->getName() );
-
-    checkSeq( xNewTD->getGetExceptions(), xExistingTD->getGetExceptions(),
-              xNewTD->getName() + ", getter exceptions" );
-    checkSeq( xNewTD->getSetExceptions(), xExistingTD->getSetExceptions(),
-              xNewTD->getName() + ", setter exceptions" );
-}
-
-void checkProperty(
-    Reference<reflection::XPropertyTypeDescription> const & xNewTD,
-    Reference<reflection::XPropertyTypeDescription> const & xExistingTD )
-{
-    if (xNewTD->getPropertyFlags() != xExistingTD->getPropertyFlags())
-    {
-        OUStringBuffer buf;
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
-                             "Different set of property flags: { ") );
-        buf.append( getPropertyFlagsAsString(
-                        xNewTD->getPropertyFlags() ) );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" } (new), { ") );
-        buf.append( getPropertyFlagsAsString(
-                        xExistingTD->getPropertyFlags() ) );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" } (existing)!") );
-        typeError( buf.makeStringAndClear(), xNewTD->getName() );
-    }
-
-    check( xNewTD->getPropertyTypeDescription(),
-           xExistingTD->getPropertyTypeDescription(),
-           xNewTD->getName() );
-}
-
-void checkSingleton(
-    Reference<reflection::XSingletonTypeDescription2> const & xNewTD,
-    Reference<reflection::XSingletonTypeDescription2> const & xExistingTD )
-{
-    sal_Bool ifaceBased = xNewTD->isInterfaceBased();
-    if (ifaceBased != xExistingTD->isInterfaceBased())
-        typeError(
-            "Mixing interface and NON-interface based singletons!",
-            xNewTD->getName() );
-    if (ifaceBased)
-        check( xNewTD->getInterface(), xExistingTD->getInterface(),
-               xNewTD->getName() );
-    else
-        check( xNewTD->getService().get(), xExistingTD->getService().get(),
-               xNewTD->getName() );
-}
-
-void checkService(
-    Reference<reflection::XServiceTypeDescription2> const & xNewTD,
-    Reference<reflection::XServiceTypeDescription2> const & xExistingTD )
-{
-    sal_Bool singleIfaceBased = xNewTD->isSingleInterfaceBased();
-    if (singleIfaceBased != xExistingTD->isSingleInterfaceBased())
-        typeError( "Mixing interface and NON-interface based services!",
-                   xNewTD->getName() );
-    if (singleIfaceBased)
-    {
-        check( xNewTD->getInterface(), xExistingTD->getInterface(),
-               xNewTD->getName() );
-        Sequence< Reference<reflection::XServiceConstructorDescription> >
-            newCtors( xNewTD->getConstructors() );
-        Sequence< Reference<reflection::XServiceConstructorDescription> >
-            existingCtors( xExistingTD->getConstructors() );
-        sal_Int32 len = newCtors.getLength();
-        if (len != existingCtors.getLength())
-            typeError( "Different number of service constructors!",
-                       xNewTD->getName() );
-        Reference<reflection::XServiceConstructorDescription> const *
-            pNewCtors = newCtors.getConstArray();
-        Reference<reflection::XServiceConstructorDescription> const *
-            pExistingCtors = existingCtors.getConstArray();
-        for ( sal_Int32 pos = 0; pos < len; ++pos )
-        {
-            Reference<reflection::XServiceConstructorDescription> const &
-                xNewCtor = pNewCtors[pos];
-            Reference<reflection::XServiceConstructorDescription> const &
-                xExistingCtor = pExistingCtors[pos];
-
-            if (xNewCtor->getName() != xExistingCtor->getName())
-            {
-                OUStringBuffer buf;
-                buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
-                                     "Different constructor names: ") );
-                buf.append( xNewCtor->getName() );
-                buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
-                buf.append( xExistingCtor->getName() );
-                buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
-                typeError( buf.makeStringAndClear(), xNewTD->getName() );
-            }
-
-            OUStringBuffer buf;
-            buf.append( xNewTD->getName() );
-            buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", constructor ") );
-            buf.append( xNewCtor->getName() );
-            OUString context( buf.makeStringAndClear() );
-            checkParameters( xNewCtor->getParameters(),
-                             xExistingCtor->getParameters(),
-                             context );
-            checkSeq( xNewCtor->getExceptions(), xExistingCtor->getExceptions(),
-                      context + ", exceptions" );
-        }
-    }
-    else // old-style service descriptions:
-    {
-        checkSeq( xNewTD->getMandatoryServices(),
-                  xExistingTD->getMandatoryServices(),
-                  xNewTD->getName() + ", mandatory services" );
-        checkSeq( xNewTD->getOptionalServices(),
-                  xExistingTD->getOptionalServices(),
-                  xNewTD->getName() + ", optional services",
-                  true /* optionalMode */ );
-        checkSeq( xNewTD->getMandatoryInterfaces(),
-                  xExistingTD->getMandatoryInterfaces(),
-                  xNewTD->getName() + ", mandatory interfaces" );
-        checkSeq( xNewTD->getOptionalInterfaces(),
-                  xExistingTD->getOptionalInterfaces(),
-                  xNewTD->getName() + ", optional interfaces",
-                  true /* optionalMode */ );
-
-        Sequence< Reference<reflection::XPropertyTypeDescription> >
-            newProperties( xNewTD->getProperties() );
-        Sequence< Reference<reflection::XPropertyTypeDescription> >
-            existingProperties( xExistingTD->getProperties() );
-        checkSeq( newProperties, existingProperties,
-                  xNewTD->getName() + ", properties",
-                  true /* optionalMode */ );
-        if (newProperties.getLength() > existingProperties.getLength())
-        {
-            // check whether all added properties are OPTIONAL:
-            Reference<reflection::XPropertyTypeDescription> const *
-                pNewProperties = newProperties.getConstArray();
-            for ( sal_Int32 pos = existingProperties.getLength() + 1;
-                  pos < newProperties.getLength(); ++pos )
-            {
-                if ((pNewProperties[pos]->getPropertyFlags() &
-                     beans::PropertyAttribute::OPTIONAL) == 0)
-                    typeError( "New property is not OPTIONAL!",
-                               pNewProperties[pos]->getName() );
-            }
-        }
-    }
-}
-
-}
-
-namespace stoc_tdmgr {
-
-void check( Reference<reflection::XTypeDescription> const & xNewTD,
-            Reference<reflection::XTypeDescription> const & xExistingTD,
-            OUString const & context )
-{
-    if (xNewTD == xExistingTD)
-        return;
-    if (xNewTD->getName() != xExistingTD->getName())
-    {
-        OUStringBuffer buf;
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("Different type names: ") );
-        buf.append( xNewTD->getName() );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
-        buf.append( xExistingTD->getName() );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
-        typeError( buf.makeStringAndClear(), context );
-    }
-
-    TypeClass tc = xNewTD->getTypeClass();
-    if (tc != xExistingTD->getTypeClass())
-    {
-        OUStringBuffer buf;
-        buf.append( xNewTD->getName() );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
-                             " has different type classes: ") );
-        buf.append( getTypeClassName( tc ) );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (new), ") );
-        buf.append( getTypeClassName( xExistingTD->getTypeClass() ) );
-        buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" (existing)!") );
-        typeError( buf.makeStringAndClear(), context );
-    }
-
-    switch (tc)
-    {
-    case TypeClass_ENUM:
-        checkEnum( Reference<reflection::XEnumTypeDescription>(
-                       xNewTD, UNO_QUERY_THROW ),
-                   Reference<reflection::XEnumTypeDescription>(
-                       xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    case TypeClass_TYPEDEF:
-    case TypeClass_SEQUENCE:
-        check( Reference<reflection::XIndirectTypeDescription>(
-                   xNewTD, UNO_QUERY_THROW )->getReferencedType(),
-               Reference<reflection::XIndirectTypeDescription>(
-                   xExistingTD, UNO_QUERY_THROW )->getReferencedType() );
-        break;
-
-    case TypeClass_STRUCT:
-    case TypeClass_EXCEPTION:
-        checkStruct( Reference<reflection::XCompoundTypeDescription>(
-                         xNewTD, UNO_QUERY_THROW ),
-                     Reference<reflection::XCompoundTypeDescription>(
-                         xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    case TypeClass_INTERFACE:
-        checkInterface( Reference<reflection::XInterfaceTypeDescription2>(
-                            xNewTD, UNO_QUERY_THROW ),
-                        Reference<reflection::XInterfaceTypeDescription2>(
-                            xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    case TypeClass_SERVICE:
-        checkService( Reference<reflection::XServiceTypeDescription2>(
-                          xNewTD, UNO_QUERY_THROW ),
-                      Reference<reflection::XServiceTypeDescription2>(
-                          xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    case TypeClass_INTERFACE_METHOD:
-        checkMethod( Reference<reflection::XInterfaceMethodTypeDescription>(
-                         xNewTD, UNO_QUERY_THROW ),
-                     Reference<reflection::XInterfaceMethodTypeDescription>(
-                         xExistingTD, UNO_QUERY_THROW ) );
-        break;
-    case TypeClass_INTERFACE_ATTRIBUTE:
-        checkAttribute(
-            Reference<reflection::XInterfaceAttributeTypeDescription2>(
-                xNewTD, UNO_QUERY_THROW ),
-            Reference<reflection::XInterfaceAttributeTypeDescription2>(
-                xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    case TypeClass_PROPERTY:
-        checkProperty( Reference<reflection::XPropertyTypeDescription>(
-                           xNewTD, UNO_QUERY_THROW ),
-                       Reference<reflection::XPropertyTypeDescription>(
-                           xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    case TypeClass_CONSTANT:
-        if (Reference<reflection::XConstantTypeDescription>(
-                xNewTD, UNO_QUERY_THROW )->getConstantValue() !=
-            Reference<reflection::XConstantTypeDescription>(
-                xExistingTD, UNO_QUERY_THROW )->getConstantValue())
-            typeError( "Different constant value!", xNewTD->getName() );
-        break;
-    case TypeClass_CONSTANTS:
-        checkSeq( Reference<reflection::XConstantsTypeDescription>(
-                      xNewTD, UNO_QUERY_THROW )->getConstants(),
-                  Reference<reflection::XConstantsTypeDescription>(
-                      xExistingTD, UNO_QUERY_THROW )->getConstants(),
-                  xNewTD->getName() );
-        break;
-
-    case TypeClass_SINGLETON:
-        checkSingleton( Reference<reflection::XSingletonTypeDescription2>(
-                            xNewTD, UNO_QUERY_THROW ),
-                        Reference<reflection::XSingletonTypeDescription2>(
-                            xExistingTD, UNO_QUERY_THROW ) );
-        break;
-
-    default:
-        break;
-    }
-}
-
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/tdmanager/tdmgr_common.hxx b/stoc/source/tdmanager/tdmgr_common.hxx
deleted file mode 100644
index eb3bcdec850f..000000000000
--- a/stoc/source/tdmanager/tdmgr_common.hxx
+++ /dev/null
@@ -1,48 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#ifndef _STOC_TDMGR_COMMON_HXX
-#define _STOC_TDMGR_COMMON_HXX
-
-#include "com/sun/star/reflection/XTypeDescription.hpp"
-
-#define ARLEN(x) (sizeof (x) / sizeof *(x))
-
-
-namespace stoc_tdmgr
-{
-
-struct IncompatibleTypeException
-{
-    OUString m_cause;
-    IncompatibleTypeException( OUString const & cause )
-        : m_cause( cause ) {}
-};
-
-void check(
-    css::uno::Reference<css::reflection::XTypeDescription> const & xNewTD,
-    css::uno::Reference<css::reflection::XTypeDescription> const & xExistingTD,
-    OUString const & context = OUString() );
-/* throw (css::uno::RuntimeException, IncompatibleTypeException) */
-
-} // namespace stoc_tdmgr
-
-#endif /* _STOC_TDMGR_COMMON_HXX */
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/tdmanager/tdmgr_tdenumeration.cxx b/stoc/source/tdmanager/tdmgr_tdenumeration.cxx
deleted file mode 100644
index ac71a1a0aa47..000000000000
--- a/stoc/source/tdmanager/tdmgr_tdenumeration.cxx
+++ /dev/null
@@ -1,170 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#include <osl/diagnose.h>
-#include "tdmgr_common.hxx"
-#include "tdmgr_tdenumeration.hxx"
-
-using namespace com::sun::star;
-
-namespace stoc_tdmgr
-{
-
-//=========================================================================
-//=========================================================================
-//
-// TypeDescriptionEnumerationImpl Implementation.
-//
-//=========================================================================
-//=========================================================================
-
-TypeDescriptionEnumerationImpl::TypeDescriptionEnumerationImpl(
-        const OUString & rModuleName,
-        const com::sun::star::uno::Sequence<
-            com::sun::star::uno::TypeClass > & rTypes,
-        com::sun::star::reflection::TypeDescriptionSearchDepth eDepth,
-        const TDEnumerationAccessStack & rTDEAS )
-: m_aModuleName( rModuleName ),
-  m_aTypes( rTypes ),
-  m_eDepth( eDepth ),
-  m_aChildren( rTDEAS )
-{
-}
-
-//=========================================================================
-// virtual
-TypeDescriptionEnumerationImpl::~TypeDescriptionEnumerationImpl()
-{
-}
-
-//=========================================================================
-//
-// XEnumeration (base of XTypeDescriptionEnumeration) methods
-//
-//=========================================================================
-
-// virtual
-sal_Bool SAL_CALL TypeDescriptionEnumerationImpl::hasMoreElements()
-    throw ( uno::RuntimeException )
-{
-    uno::Reference< reflection::XTypeDescriptionEnumeration > xEnum
-        = queryCurrentChildEnumeration();
-    if ( xEnum.is() )
-        return xEnum->hasMoreElements();
-
-    return sal_False;
-}
-
-//=========================================================================
-// virtual
-uno::Any SAL_CALL TypeDescriptionEnumerationImpl::nextElement()
-    throw ( container::NoSuchElementException,
-            lang::WrappedTargetException,
-            uno::RuntimeException )
-{
-    uno::Reference< reflection::XTypeDescriptionEnumeration > xEnum
-        = queryCurrentChildEnumeration();
-    if ( xEnum.is() )
-        return xEnum->nextElement();
-
-    throw container::NoSuchElementException(
-        OUString("No further elements in enumeration!"),
-        static_cast< cppu::OWeakObject * >( this  ) );
-}
-
-//=========================================================================
-//
-// XTypeDescriptionEnumeration methods
-//
-//=========================================================================
-
-// virtual
-uno::Reference< reflection::XTypeDescription > SAL_CALL
-TypeDescriptionEnumerationImpl::nextTypeDescription()
-    throw ( container::NoSuchElementException,
-            uno::RuntimeException )
-{
-    uno::Reference< reflection::XTypeDescriptionEnumeration > xEnum
-        = queryCurrentChildEnumeration();
-    if ( xEnum.is() )
-        return xEnum->nextTypeDescription();
-
-    throw container::NoSuchElementException(
-        OUString("No further elements in enumeration!"),
-        static_cast< cppu::OWeakObject * >( this  ) );
-}
-
-//=========================================================================
-uno::Reference< reflection::XTypeDescriptionEnumeration >
-TypeDescriptionEnumerationImpl::queryCurrentChildEnumeration()
-{
-    osl::MutexGuard aGuard( m_aMutex );
-
-    for (;;)
-    {
-        if ( m_xEnum.is() )
-        {
-            if ( m_xEnum->hasMoreElements() )
-            {
-                return m_xEnum;
-            }
-            else
-            {
-                // Forget about enumeration without further elements. Try next.
-                m_xEnum.clear();
-            }
-        }
-
-        // Note: m_xEnum is always null here.
-
-        if ( m_aChildren.empty() )
-        {
-            // No child enumerations left.
-            return m_xEnum;
-        }
-
-        try
-        {
-            m_xEnum =
-                m_aChildren.top()->createTypeDescriptionEnumeration(
-                    m_aModuleName, m_aTypes, m_eDepth );
-        }
-        catch ( reflection::NoSuchTypeNameException const & )
-        {
-            OSL_FAIL( "TypeDescriptionEnumerationImpl::queryCurrentChildEnumeration "
-               "- Caught NoSuchTypeNameException!" );
-        }
-        catch ( reflection::InvalidTypeNameException const & )
-        {
-            OSL_FAIL( "TypeDescriptionEnumerationImpl::queryCurrentChildEnumeration "
-               "- Caught InvalidTypeNameException!" );
-        }
-
-        // We're done with this enumeration access in any case (Either
-        // enumeration was successfully created or creation failed for some
-        // reason).
-        m_aChildren.pop();
-    }
-
-    // unreachable
-}
-
-} // namespace stoc_tdmgr
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/tdmanager/tdmgr_tdenumeration.hxx b/stoc/source/tdmanager/tdmgr_tdenumeration.hxx
deleted file mode 100644
index 81672ce5c0f8..000000000000
--- a/stoc/source/tdmanager/tdmgr_tdenumeration.hxx
+++ /dev/null
@@ -1,82 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#ifndef _STOC_TDMGR_TDENUMERATION_HXX
-#define _STOC_TDMGR_TDENUMERATION_HXX
-
-#include <stack>
-#include <osl/mutex.hxx>
-#include <com/sun/star/reflection/XTypeDescriptionEnumeration.hpp>
-#include <com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp>
-#include <cppuhelper/implbase1.hxx>
-
-namespace stoc_tdmgr
-{
-
-typedef std::stack< com::sun::star::uno::Reference<
-            com::sun::star::reflection::XTypeDescriptionEnumerationAccess > >
-                TDEnumerationAccessStack;
-
-class TypeDescriptionEnumerationImpl
-    : public cppu::WeakImplHelper1<
-                com::sun::star::reflection::XTypeDescriptionEnumeration >
-{
-public:
-    TypeDescriptionEnumerationImpl(
-        const OUString & rModuleName,
-        const com::sun::star::uno::Sequence<
-            com::sun::star::uno::TypeClass > & rTypes,
-        com::sun::star::reflection::TypeDescriptionSearchDepth eDepth,
-        const TDEnumerationAccessStack & rTDEAS );
-    virtual ~TypeDescriptionEnumerationImpl();
-
-    // XEnumeration (base of XTypeDescriptionEnumeration)
-    virtual sal_Bool SAL_CALL hasMoreElements()
-        throw ( ::com::sun::star::uno::RuntimeException );
-    virtual ::com::sun::star::uno::Any SAL_CALL nextElement()
-        throw ( ::com::sun::star::container::NoSuchElementException,
-                ::com::sun::star::lang::WrappedTargetException,
-                ::com::sun::star::uno::RuntimeException );
-
-    // XTypeDescriptionEnumeration
-    virtual ::com::sun::star::uno::Reference<
-        ::com::sun::star::reflection::XTypeDescription > SAL_CALL
-    nextTypeDescription()
-        throw ( ::com::sun::star::container::NoSuchElementException,
-                ::com::sun::star::uno::RuntimeException );
-
-private:
-    com::sun::star::uno::Reference<
-        com::sun::star::reflection::XTypeDescriptionEnumeration >
-    queryCurrentChildEnumeration();
-
-    osl::Mutex m_aMutex;
-    OUString m_aModuleName;
-    com::sun::star::uno::Sequence< com::sun::star::uno::TypeClass > m_aTypes;
-    com::sun::star::reflection::TypeDescriptionSearchDepth m_eDepth;
-    TDEnumerationAccessStack m_aChildren;
-    com::sun::star::uno::Reference<
-        com::sun::star::reflection::XTypeDescriptionEnumeration > m_xEnum;
-};
-
-} // namespace stoc_tdmgr
-
-#endif /* _STOC_TDMGR_TDENUMERATION_HXX */
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/util/bootstrap.component b/stoc/util/bootstrap.component
index ec1aa548e2d1..59761e04edcd 100644
--- a/stoc/util/bootstrap.component
+++ b/stoc/util/bootstrap.component
@@ -41,10 +41,6 @@
   <implementation name="com.sun.star.comp.stoc.SimpleRegistry">
     <service name="com.sun.star.registry.SimpleRegistry"/>
   </implementation>
-  <implementation name="com.sun.star.comp.stoc.TypeDescriptionManager">
-    <service name="com.sun.star.reflection.TypeDescriptionManager"/>
-    <singleton name="com.sun.star.reflection.theTypeDescriptionManager"/>
-  </implementation>
   <implementation name="com.sun.star.security.comp.stoc.AccessController">
     <service name="com.sun.star.security.AccessController"/>
   </implementation>
diff --git a/unoidl/inc/unoidl/unoidl.hxx b/unoidl/inc/unoidl/unoidl.hxx
index 02435316cb58..9d774473c7ee 100644
--- a/unoidl/inc/unoidl/unoidl.hxx
+++ b/unoidl/inc/unoidl/unoidl.hxx
@@ -15,6 +15,7 @@
 #include <cassert>
 #include <vector>
 
+#include "osl/mutex.hxx"
 #include "rtl/ref.hxx"
 #include "rtl/ustring.hxx"
 #include "sal/types.h"
@@ -626,6 +627,7 @@ public:
 private:
     virtual SAL_DLLPRIVATE ~Manager() throw ();
 
+    mutable osl::Mutex mutex_;
     std::vector< rtl::Reference< Provider > > providers_;
 };
 
diff --git a/unoidl/source/unoidl.cxx b/unoidl/source/unoidl.cxx
index 2b92afd50b31..a9939e4b9755 100644
--- a/unoidl/source/unoidl.cxx
+++ b/unoidl/source/unoidl.cxx
@@ -12,6 +12,7 @@
 #include <set>
 #include <vector>
 
+#include "osl/mutex.hxx"
 #include "rtl/ref.hxx"
 #include "rtl/ustring.hxx"
 #include "unoidl/legacyprovider.hxx"
@@ -116,11 +117,13 @@ rtl::Reference< Provider > loadProvider(
 
 void Manager::addProvider(rtl::Reference< Provider > const & provider) {
     assert(provider.is());
+    osl::MutexGuard g(mutex_);
     providers_.push_back(provider);
 }
 
 rtl::Reference< Entity > Manager::findEntity(rtl::OUString const & name) const {
-    //TODO: add caching
+    //TODO: caching? (here or in cppuhelper::TypeManager?)
+    osl::MutexGuard g(mutex_);
     for (std::vector< rtl::Reference< Provider > >::const_iterator i(
              providers_.begin());
          i != providers_.end(); ++i)