Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 715 insertions, 0 deletions

diff --git a/include/unoidl/unoidl.hxx b/include/unoidl/unoidl.hxx
new file mode 100644
index 000000000..7791fcd41
--- /dev/null
+++ b/include/unoidl/unoidl.hxx
@@ -0,0 +1,715 @@
+/* -*- 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_UNOIDL_UNOIDL_HXX
+#define INCLUDED_UNOIDL_UNOIDL_HXX
+
+#include <sal/config.h>
+
+#include <cassert>
+#include <utility>
+#include <vector>
+
+#include <osl/mutex.hxx>
+#include <rtl/ref.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/types.h>
+#include <salhelper/simplereferenceobject.hxx>
+#include <unoidl/detail/dllapi.hxx>
+
+namespace unoidl {
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL NoSuchFileException final {
+public:
+    SAL_DLLPRIVATE NoSuchFileException(OUString uri): uri_(std::move(uri)) {}
+
+    SAL_DLLPRIVATE NoSuchFileException(NoSuchFileException const & other):
+        uri_(other.uri_) {}
+
+    SAL_DLLPRIVATE ~NoSuchFileException() noexcept;
+
+    const OUString& getUri() const { return uri_; }
+
+private:
+    NoSuchFileException& operator =(NoSuchFileException const &) = delete;
+
+    OUString uri_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL FileFormatException final {
+public:
+    SAL_DLLPRIVATE FileFormatException(
+        OUString uri, OUString detail):
+        uri_(std::move(uri)), detail_(std::move(detail))
+    {}
+
+    SAL_DLLPRIVATE FileFormatException(FileFormatException const & other):
+        uri_(other.uri_), detail_(other.detail_)
+    {}
+
+    SAL_DLLPRIVATE ~FileFormatException() noexcept;
+
+    const OUString& getUri() const { return uri_; }
+
+    const OUString& getDetail() const { return detail_; }
+
+private:
+    FileFormatException& operator =(FileFormatException const &) = delete;
+
+    OUString uri_;
+    OUString detail_;
+};
+
+struct AnnotatedReference {
+    AnnotatedReference(
+        OUString theName,
+        std::vector< OUString > && theAnnotations):
+        name(std::move(theName)), annotations(std::move(theAnnotations))
+    {}
+
+    OUString name;
+
+    std::vector< OUString > annotations;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL Entity: public salhelper::SimpleReferenceObject {
+public:
+    enum Sort {
+        SORT_MODULE, SORT_ENUM_TYPE, SORT_PLAIN_STRUCT_TYPE,
+        SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, SORT_EXCEPTION_TYPE,
+        SORT_INTERFACE_TYPE, SORT_TYPEDEF, SORT_CONSTANT_GROUP,
+        SORT_SINGLE_INTERFACE_BASED_SERVICE, SORT_ACCUMULATION_BASED_SERVICE,
+        SORT_INTERFACE_BASED_SINGLETON, SORT_SERVICE_BASED_SINGLETON
+    };
+
+    Sort getSort() const { return sort_; }
+
+protected:
+    explicit SAL_DLLPRIVATE Entity(Sort sort): sort_(sort) {}
+
+    virtual SAL_DLLPRIVATE ~Entity() noexcept override;
+
+private:
+    Sort sort_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL MapCursor: public salhelper::SimpleReferenceObject {
+public:
+    // throws FileFormatException:
+    virtual rtl::Reference< Entity > getNext(OUString * name) = 0;
+
+protected:
+    SAL_DLLPRIVATE MapCursor() {}
+
+    virtual SAL_DLLPRIVATE ~MapCursor() noexcept override;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL ModuleEntity: public Entity {
+public:
+    // throws FileFormatException:
+    virtual std::vector< OUString > getMemberNames() const = 0;
+
+    // throws FileFormatException:
+    virtual rtl::Reference< MapCursor > createCursor() const = 0;
+
+protected:
+    SAL_DLLPRIVATE ModuleEntity(): Entity(SORT_MODULE) {}
+
+    virtual SAL_DLLPRIVATE ~ModuleEntity() noexcept override;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL PublishableEntity: public Entity {
+public:
+    bool isPublished() const { return published_; }
+
+    std::vector< OUString > const & getAnnotations() const
+    { return annotations_; }
+
+protected:
+    SAL_DLLPRIVATE PublishableEntity(
+        Sort sort, bool published,
+        std::vector< OUString >&& annotations):
+        Entity(sort), published_(published), annotations_(std::move(annotations))
+    {}
+
+    virtual SAL_DLLPRIVATE ~PublishableEntity() noexcept override;
+
+private:
+    bool published_;
+
+    std::vector< OUString > annotations_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL EnumTypeEntity final : public PublishableEntity {
+public:
+    struct Member {
+        Member(
+            OUString theName, sal_Int32 theValue,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), value(theValue), annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        sal_Int32 value;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE EnumTypeEntity(
+        bool published, std::vector< Member >&& members,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(SORT_ENUM_TYPE, published, std::move(annotations)),
+        members_(std::move(members))
+    { assert(!members_.empty()); }
+
+    std::vector< Member > const & getMembers() const { return members_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~EnumTypeEntity() noexcept override;
+
+    std::vector< Member > members_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL PlainStructTypeEntity final : public PublishableEntity {
+public:
+    struct Member {
+        Member(OUString theName, OUString theType,
+               std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), type(std::move(theType)), annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        OUString type;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE PlainStructTypeEntity(
+        bool published, OUString directBase,
+        std::vector< Member >&& directMembers,
+        std::vector< OUString > && annotations):
+        PublishableEntity(SORT_PLAIN_STRUCT_TYPE, published, std::move(annotations)),
+        directBase_(std::move(directBase)), directMembers_(std::move(directMembers))
+    {}
+
+    const OUString& getDirectBase() const { return directBase_; }
+
+    std::vector< Member > const & getDirectMembers() const
+    { return directMembers_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~PlainStructTypeEntity() noexcept override;
+
+    OUString directBase_;
+    std::vector< Member > directMembers_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL PolymorphicStructTypeTemplateEntity final :
+    public PublishableEntity
+{
+public:
+    struct Member {
+        Member(
+            OUString theName, OUString theType,
+            bool theParameterized,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), type(std::move(theType)), parameterized(theParameterized),
+            annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        OUString type;
+
+        bool parameterized;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE PolymorphicStructTypeTemplateEntity(
+        bool published, std::vector< OUString >&& typeParameters,
+        std::vector< Member >&& members,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(
+            SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, published, std::move(annotations)),
+        typeParameters_(std::move(typeParameters)), members_(std::move(members))
+    {}
+
+    std::vector< OUString > const & getTypeParameters() const
+    { return typeParameters_; }
+
+    std::vector< Member > const & getMembers() const { return members_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~PolymorphicStructTypeTemplateEntity() noexcept override;
+
+    std::vector< OUString > typeParameters_;
+    std::vector< Member > members_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL ExceptionTypeEntity final : public PublishableEntity {
+public:
+    struct Member {
+        Member(
+            OUString theName, OUString theType,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), type(std::move(theType)), annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        OUString type;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE ExceptionTypeEntity(
+        bool published, OUString directBase,
+        std::vector< Member >&& directMembers,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(SORT_EXCEPTION_TYPE, published, std::move(annotations)),
+        directBase_(std::move(directBase)), directMembers_(std::move(directMembers))
+    {}
+
+    const OUString& getDirectBase() const { return directBase_; }
+
+    std::vector< Member > const & getDirectMembers() const
+    { return directMembers_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~ExceptionTypeEntity() noexcept override;
+
+    OUString directBase_;
+    std::vector< Member > directMembers_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL InterfaceTypeEntity final : public PublishableEntity {
+public:
+    struct Attribute {
+        Attribute(
+            OUString theName, OUString theType,
+            bool theBound, bool theReadOnly,
+            std::vector< OUString >&& theGetExceptions,
+            std::vector< OUString >&& theSetExceptions,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), type(std::move(theType)), bound(theBound),
+            readOnly(theReadOnly), getExceptions(std::move(theGetExceptions)),
+            setExceptions(std::move(theSetExceptions)), annotations(std::move(theAnnotations))
+        { assert(!theReadOnly || setExceptions.empty()); }
+
+        OUString name;
+
+        OUString type;
+
+        bool bound;
+
+        bool readOnly;
+
+        std::vector< OUString > getExceptions;
+
+        std::vector< OUString > setExceptions;
+
+        std::vector< OUString > annotations;
+    };
+
+    struct Method {
+        struct Parameter {
+            enum Direction { DIRECTION_IN, DIRECTION_OUT, DIRECTION_IN_OUT };
+
+            Parameter(
+                OUString theName, OUString theType,
+                Direction theDirection):
+                name(std::move(theName)), type(std::move(theType)), direction(theDirection)
+            {}
+
+            OUString name;
+
+            OUString type;
+
+            Direction direction;
+        };
+
+        Method(
+            OUString theName, OUString theReturnType,
+            std::vector< Parameter >&& theParameters,
+            std::vector< OUString >&& theExceptions,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), returnType(std::move(theReturnType)), parameters(std::move(theParameters)),
+            exceptions(std::move(theExceptions)), annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        OUString returnType;
+
+        std::vector< Parameter > parameters;
+
+        std::vector< OUString > exceptions;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE InterfaceTypeEntity(
+        bool published,
+        std::vector< AnnotatedReference >&& directMandatoryBases,
+        std::vector< AnnotatedReference >&& directOptionalBases,
+        std::vector< Attribute >&& directAttributes,
+        std::vector< Method >&& directMethods,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(SORT_INTERFACE_TYPE, published, std::move(annotations)),
+        directMandatoryBases_(std::move(directMandatoryBases)),
+        directOptionalBases_(std::move(directOptionalBases)),
+        directAttributes_(std::move(directAttributes)),
+        directMethods_(std::move(directMethods))
+    {}
+
+    std::vector< AnnotatedReference > const & getDirectMandatoryBases() const
+    { return directMandatoryBases_; }
+
+    std::vector< AnnotatedReference > const & getDirectOptionalBases() const
+    { return directOptionalBases_; }
+
+    std::vector< Attribute > const & getDirectAttributes() const
+    { return directAttributes_; }
+
+    std::vector< Method > const & getDirectMethods() const
+    { return directMethods_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~InterfaceTypeEntity() noexcept override;
+
+    std::vector< AnnotatedReference > directMandatoryBases_;
+    std::vector< AnnotatedReference > directOptionalBases_;
+    std::vector< Attribute > directAttributes_;
+    std::vector< Method > directMethods_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL TypedefEntity final : public PublishableEntity {
+public:
+    SAL_DLLPRIVATE TypedefEntity(
+        bool published, OUString type,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(SORT_TYPEDEF, published, std::move(annotations)), type_(std::move(type))
+    {}
+
+    const OUString& getType() const { return type_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~TypedefEntity() noexcept override;
+
+    OUString type_;
+};
+
+struct SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL ConstantValue {
+    enum Type {
+        TYPE_BOOLEAN, TYPE_BYTE, TYPE_SHORT, TYPE_UNSIGNED_SHORT, TYPE_LONG,
+        TYPE_UNSIGNED_LONG, TYPE_HYPER, TYPE_UNSIGNED_HYPER, TYPE_FLOAT,
+        TYPE_DOUBLE };
+
+    ConstantValue(bool value): type(TYPE_BOOLEAN), booleanValue(value) {}
+
+    ConstantValue(sal_Int8 value): type(TYPE_BYTE), byteValue(value) {}
+
+    ConstantValue(sal_Int16 value): type(TYPE_SHORT), shortValue(value) {}
+
+    ConstantValue(sal_uInt16 value):
+        type(TYPE_UNSIGNED_SHORT), unsignedShortValue(value)
+    {}
+
+    ConstantValue(sal_Int32 value): type(TYPE_LONG), longValue(value) {}
+
+    ConstantValue(sal_uInt32 value):
+        type(TYPE_UNSIGNED_LONG), unsignedLongValue(value)
+    {}
+
+    ConstantValue(sal_Int64 value): type(TYPE_HYPER), hyperValue(value) {}
+
+    ConstantValue(sal_uInt64 value):
+        type(TYPE_UNSIGNED_HYPER), unsignedHyperValue(value)
+    {}
+
+    ConstantValue(float value): type(TYPE_FLOAT), floatValue(value) {}
+
+    ConstantValue(double value): type(TYPE_DOUBLE), doubleValue(value) {}
+
+    Type type;
+
+    union {
+        bool booleanValue;
+        sal_Int8 byteValue;
+        sal_Int16 shortValue;
+        sal_uInt16 unsignedShortValue;
+        sal_Int32 longValue;
+        sal_uInt32 unsignedLongValue;
+        sal_Int64 hyperValue;
+        sal_uInt64 unsignedHyperValue;
+        float floatValue;
+        double doubleValue;
+    };
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL ConstantGroupEntity final : public PublishableEntity {
+public:
+    struct Member {
+        Member(
+            OUString theName, ConstantValue const & theValue,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), value(theValue), annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        ConstantValue value;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE ConstantGroupEntity(
+        bool published, std::vector< Member >&& members,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(SORT_CONSTANT_GROUP, published, std::move(annotations)),
+        members_(std::move(members))
+    {}
+
+    std::vector< Member > const & getMembers() const { return members_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~ConstantGroupEntity() noexcept override;
+
+    std::vector< Member > members_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL SingleInterfaceBasedServiceEntity final :
+    public PublishableEntity
+{
+public:
+    struct Constructor {
+        struct Parameter {
+            Parameter(
+                OUString theName, OUString theType,
+                bool theRest):
+                name(std::move(theName)), type(std::move(theType)), rest(theRest)
+            {}
+
+            OUString name;
+
+            OUString type;
+
+            bool rest;
+        };
+
+        Constructor():
+            defaultConstructor(true) {}
+
+        Constructor(
+            OUString theName,
+            std::vector< Parameter >&& theParameters,
+            std::vector< OUString >&& theExceptions,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), parameters(std::move(theParameters)),
+            exceptions(std::move(theExceptions)),
+            annotations(std::move(theAnnotations)),
+            defaultConstructor(false)
+        {}
+
+        OUString name;
+
+        std::vector< Parameter > parameters;
+
+        std::vector< OUString > exceptions;
+
+        std::vector< OUString > annotations;
+
+        bool defaultConstructor;
+    };
+
+    SAL_DLLPRIVATE SingleInterfaceBasedServiceEntity(
+        bool published, OUString base,
+        std::vector< Constructor >&& constructors,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(
+            SORT_SINGLE_INTERFACE_BASED_SERVICE, published, std::move(annotations)),
+        base_(std::move(base)), constructors_(std::move(constructors))
+    {}
+
+    const OUString& getBase() const { return base_; }
+
+    std::vector< Constructor > const & getConstructors() const
+    { return constructors_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~SingleInterfaceBasedServiceEntity() noexcept override;
+
+    OUString base_;
+    std::vector< Constructor > constructors_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL AccumulationBasedServiceEntity final :
+    public PublishableEntity
+{
+public:
+    struct Property {
+        enum Attributes {
+            ATTRIBUTE_MAYBE_VOID = 0x001,
+            ATTRIBUTE_BOUND = 0x002,
+            ATTRIBUTE_CONSTRAINED = 0x004,
+            ATTRIBUTE_TRANSIENT = 0x008,
+            ATTRIBUTE_READ_ONLY = 0x010,
+            ATTRIBUTE_MAYBE_AMBIGUOUS = 0x020,
+            ATTRIBUTE_MAYBE_DEFAULT = 0x040,
+            ATTRIBUTE_REMOVABLE = 0x080,
+            ATTRIBUTE_OPTIONAL = 0x100
+        };
+
+        Property(
+            OUString theName, OUString theType,
+            Attributes theAttributes,
+            std::vector< OUString >&& theAnnotations):
+            name(std::move(theName)), type(std::move(theType)), attributes(theAttributes),
+            annotations(std::move(theAnnotations))
+        {}
+
+        OUString name;
+
+        OUString type;
+
+        Attributes attributes;
+
+        std::vector< OUString > annotations;
+    };
+
+    SAL_DLLPRIVATE AccumulationBasedServiceEntity(
+        bool published,
+        std::vector< AnnotatedReference >&& directMandatoryBaseServices,
+        std::vector< AnnotatedReference >&& directOptionalBaseServices,
+        std::vector< AnnotatedReference >&& directMandatoryBaseInterfaces,
+        std::vector< AnnotatedReference >&& directOptionalBaseInterfaces,
+        std::vector< Property >&& directProperties,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(
+            SORT_ACCUMULATION_BASED_SERVICE, published, std::move(annotations)),
+        directMandatoryBaseServices_(std::move(directMandatoryBaseServices)),
+        directOptionalBaseServices_(std::move(directOptionalBaseServices)),
+        directMandatoryBaseInterfaces_(std::move(directMandatoryBaseInterfaces)),
+        directOptionalBaseInterfaces_(std::move(directOptionalBaseInterfaces)),
+        directProperties_(std::move(directProperties))
+        {}
+
+    std::vector< AnnotatedReference > const & getDirectMandatoryBaseServices()
+        const
+    { return directMandatoryBaseServices_; }
+
+    std::vector< AnnotatedReference > const & getDirectOptionalBaseServices()
+        const
+    { return directOptionalBaseServices_; }
+
+    std::vector< AnnotatedReference > const & getDirectMandatoryBaseInterfaces()
+        const
+    { return directMandatoryBaseInterfaces_; }
+
+    std::vector< AnnotatedReference > const & getDirectOptionalBaseInterfaces()
+        const
+    { return directOptionalBaseInterfaces_; }
+
+    std::vector< Property > const & getDirectProperties() const
+    { return directProperties_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~AccumulationBasedServiceEntity() noexcept override;
+
+    std::vector< AnnotatedReference > directMandatoryBaseServices_;
+    std::vector< AnnotatedReference > directOptionalBaseServices_;
+    std::vector< AnnotatedReference > directMandatoryBaseInterfaces_;
+    std::vector< AnnotatedReference > directOptionalBaseInterfaces_;
+    std::vector< Property > directProperties_;
+};
+
+class LO_DLLPUBLIC_UNOIDL InterfaceBasedSingletonEntity final :
+    public PublishableEntity
+{
+public:
+    SAL_DLLPRIVATE InterfaceBasedSingletonEntity(
+        bool published, OUString base,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(
+            SORT_INTERFACE_BASED_SINGLETON, published, std::move(annotations)),
+        base_(std::move(base))
+    {}
+
+    const OUString& getBase() const { return base_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~InterfaceBasedSingletonEntity() noexcept override;
+
+    OUString base_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL ServiceBasedSingletonEntity final : public PublishableEntity
+{
+public:
+    SAL_DLLPRIVATE ServiceBasedSingletonEntity(
+        bool published, OUString base,
+        std::vector< OUString >&& annotations):
+        PublishableEntity(SORT_SERVICE_BASED_SINGLETON, published, std::move(annotations)),
+        base_(std::move(base))
+    {}
+
+    const OUString& getBase() const { return base_; }
+
+private:
+    virtual SAL_DLLPRIVATE ~ServiceBasedSingletonEntity() noexcept override;
+
+    OUString base_;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL Provider: public salhelper::SimpleReferenceObject {
+public:
+    // throws FileFormatException:
+    virtual rtl::Reference< MapCursor > createRootCursor() const = 0;
+
+    // throws FileFormatException:
+    virtual rtl::Reference< Entity > findEntity(OUString const & name)
+        const = 0;
+
+protected:
+    SAL_DLLPRIVATE Provider() {}
+
+    virtual SAL_DLLPRIVATE ~Provider() noexcept override;
+};
+
+class SAL_WARN_UNUSED LO_DLLPUBLIC_UNOIDL Manager final : public salhelper::SimpleReferenceObject {
+public:
+    Manager() {}
+
+    // throws FileFormatException, NoSuchFileException:
+    rtl::Reference< Provider > addProvider(OUString const & uri);
+
+    // throws FileFormatException:
+    rtl::Reference< Entity > findEntity(OUString const & name) const;
+
+    // throws FileFormatException:
+    rtl::Reference< MapCursor > createCursor(OUString const & name) const;
+
+private:
+    virtual SAL_DLLPRIVATE ~Manager() noexcept override;
+
+    SAL_DLLPRIVATE rtl::Reference< Provider > loadProvider(
+        OUString const & uri);
+
+    mutable osl::Mutex mutex_;
+    std::vector< rtl::Reference< Provider > > providers_;
+};
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */