75918e709a
Change-Id: Ibeb6aa656d6ed8b8ba78e800c9e28ba63ec0ec40 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/134521 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
715 lines
22 KiB
C++
715 lines
22 KiB
C++
/* -*- 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: */
|