diff options
Diffstat (limited to 'include/unoidl/unoidl.hxx')
-rw-r--r-- | include/unoidl/unoidl.hxx | 642 |
1 files changed, 642 insertions, 0 deletions
diff --git a/include/unoidl/unoidl.hxx b/include/unoidl/unoidl.hxx new file mode 100644 index 000000000000..9d774473c7ee --- /dev/null +++ b/include/unoidl/unoidl.hxx @@ -0,0 +1,642 @@ +/* -*- 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 <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 LO_DLLPUBLIC_UNOIDL NoSuchFileException { +public: + SAL_DLLPRIVATE NoSuchFileException(rtl::OUString const & uri): uri_(uri) {} + + SAL_DLLPRIVATE NoSuchFileException(NoSuchFileException const & other): + uri_(other.uri_) {} + + virtual SAL_DLLPRIVATE ~NoSuchFileException() throw (); + + rtl::OUString getUri() const { return uri_; } + +private: + void operator =(NoSuchFileException) SAL_DELETED_FUNCTION; + + rtl::OUString uri_; +}; + +class LO_DLLPUBLIC_UNOIDL FileFormatException { +public: + SAL_DLLPRIVATE FileFormatException( + rtl::OUString const & uri, rtl::OUString const & detail): + uri_(uri), detail_(detail) + {} + + SAL_DLLPRIVATE FileFormatException(FileFormatException const & other): + uri_(other.uri_), detail_(other.detail_) + {} + + virtual SAL_DLLPRIVATE ~FileFormatException() throw (); + + rtl::OUString getUri() const { return uri_; } + + rtl::OUString getDetail() const { return detail_; } + +private: + void operator =(FileFormatException) SAL_DELETED_FUNCTION; + + rtl::OUString uri_; + rtl::OUString detail_; +}; + +class 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() throw (); + +private: + Sort sort_; +}; + +class LO_DLLPUBLIC_UNOIDL MapCursor: public salhelper::SimpleReferenceObject { +public: + // throws FileFormatException: + virtual rtl::Reference< Entity > getNext(rtl::OUString * name) = 0; + +protected: + SAL_DLLPRIVATE MapCursor() {} + + virtual SAL_DLLPRIVATE ~MapCursor() throw(); +}; + +class LO_DLLPUBLIC_UNOIDL ModuleEntity: public Entity { +public: + // throws FileFormatException: + virtual std::vector< rtl::OUString > getMemberNames() const = 0; + + // throws FileFormatException: + virtual rtl::Reference< MapCursor > createCursor() const = 0; + +protected: + SAL_DLLPRIVATE ModuleEntity(): Entity(SORT_MODULE) {} + + virtual SAL_DLLPRIVATE ~ModuleEntity() throw (); +}; + +class LO_DLLPUBLIC_UNOIDL PublishableEntity: public Entity { +public: + bool isPublished() const { return published_; } + +protected: + SAL_DLLPRIVATE PublishableEntity(Sort sort, bool published): + Entity(sort), published_(published) + {} + + virtual SAL_DLLPRIVATE ~PublishableEntity() throw (); + +private: + bool published_; +}; + +class LO_DLLPUBLIC_UNOIDL EnumTypeEntity: public PublishableEntity { +public: + struct Member { + Member(rtl::OUString const & theName, sal_Int32 theValue): + name(theName), value(theValue) + {} + + rtl::OUString name; + + sal_Int32 value; + }; + + SAL_DLLPRIVATE EnumTypeEntity( + bool published, std::vector< Member > const & members): + PublishableEntity(SORT_ENUM_TYPE, published), members_(members) + { assert(!members.empty()); } + + std::vector< Member > const & getMembers() const { return members_; } + +private: + virtual SAL_DLLPRIVATE ~EnumTypeEntity() throw (); + + std::vector< Member > members_; +}; + +class LO_DLLPUBLIC_UNOIDL PlainStructTypeEntity: public PublishableEntity { +public: + struct Member { + Member(rtl::OUString const & theName, rtl::OUString const & theType): + name(theName), type(theType) + {} + + rtl::OUString name; + + rtl::OUString type; + }; + + SAL_DLLPRIVATE PlainStructTypeEntity( + bool published, rtl::OUString const & directBase, + std::vector< Member > const & directMembers): + PublishableEntity(SORT_PLAIN_STRUCT_TYPE, published), + directBase_(directBase), directMembers_(directMembers) + {} + + rtl::OUString getDirectBase() const { return directBase_; } + + std::vector< Member > const & getDirectMembers() const + { return directMembers_; } + +private: + virtual SAL_DLLPRIVATE ~PlainStructTypeEntity() throw (); + + rtl::OUString directBase_; + std::vector< Member > directMembers_; +}; + +class LO_DLLPUBLIC_UNOIDL PolymorphicStructTypeTemplateEntity: + public PublishableEntity +{ +public: + struct Member { + Member( + rtl::OUString const & theName, rtl::OUString const & theType, + bool theParameterized): + name(theName), type(theType), parameterized(theParameterized) + {} + + rtl::OUString name; + + rtl::OUString type; + + bool parameterized; + }; + + SAL_DLLPRIVATE PolymorphicStructTypeTemplateEntity( + bool published, std::vector< rtl::OUString > const & typeParameters, + std::vector< Member > const & members): + PublishableEntity(SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, published), + typeParameters_(typeParameters), members_(members) + {} + + std::vector< rtl::OUString > const & getTypeParameters() const + { return typeParameters_; } + + std::vector< Member > const & getMembers() const { return members_; } + +private: + virtual SAL_DLLPRIVATE ~PolymorphicStructTypeTemplateEntity() throw (); + + std::vector< rtl::OUString > typeParameters_; + std::vector< Member > members_; +}; + +class LO_DLLPUBLIC_UNOIDL ExceptionTypeEntity: public PublishableEntity { +public: + struct Member { + Member(rtl::OUString const & theName, rtl::OUString const & theType): + name(theName), type(theType) + {} + + rtl::OUString name; + + rtl::OUString type; + }; + + SAL_DLLPRIVATE ExceptionTypeEntity( + bool published, rtl::OUString const & directBase, + std::vector< Member > const & directMembers): + PublishableEntity(SORT_EXCEPTION_TYPE, published), + directBase_(directBase), directMembers_(directMembers) + {} + + rtl::OUString getDirectBase() const { return directBase_; } + + std::vector< Member > const & getDirectMembers() const + { return directMembers_; } + +private: + virtual SAL_DLLPRIVATE ~ExceptionTypeEntity() throw (); + + rtl::OUString directBase_; + std::vector< Member > directMembers_; +}; + +class LO_DLLPUBLIC_UNOIDL InterfaceTypeEntity: public PublishableEntity { +public: + struct Attribute { + Attribute( + rtl::OUString const & theName, rtl::OUString const & theType, + bool theBound, bool theReadOnly, + std::vector< rtl::OUString > const & theGetExceptions, + std::vector< rtl::OUString > const & theSetExceptions): + name(theName), type(theType), bound(theBound), + readOnly(theReadOnly), getExceptions(theGetExceptions), + setExceptions(theSetExceptions) + { assert(!theReadOnly || theSetExceptions.empty()); } + + rtl::OUString name; + + rtl::OUString type; + + bool bound; + + bool readOnly; + + std::vector< rtl::OUString > getExceptions; + + std::vector< rtl::OUString > setExceptions; + }; + + struct Method { + struct Parameter { + enum Direction { DIRECTION_IN, DIRECTION_OUT, DIRECTION_IN_OUT }; + + Parameter( + rtl::OUString const & theName, rtl::OUString const & theType, + Direction theDirection): + name(theName), type(theType), direction(theDirection) + {} + + rtl::OUString name; + + rtl::OUString type; + + Direction direction; + }; + + Method( + rtl::OUString const & theName, rtl::OUString const & theReturnType, + std::vector< Parameter > const & theParameters, + std::vector< rtl::OUString > const & theExceptions): + name(theName), returnType(theReturnType), parameters(theParameters), + exceptions(theExceptions) + {} + + rtl::OUString name; + + rtl::OUString returnType; + + std::vector< Parameter > parameters; + + std::vector< rtl::OUString > exceptions; + }; + + SAL_DLLPRIVATE InterfaceTypeEntity( + bool published, + std::vector< rtl::OUString > const & directMandatoryBases, + std::vector< rtl::OUString > const & directOptionalBases, + std::vector< Attribute > const & directAttributes, + std::vector< Method > const & directMethods): + PublishableEntity(SORT_INTERFACE_TYPE, published), + directMandatoryBases_(directMandatoryBases), + directOptionalBases_(directOptionalBases), + directAttributes_(directAttributes), directMethods_(directMethods) + {} + + std::vector< rtl::OUString > const & getDirectMandatoryBases() const + { return directMandatoryBases_; } + + std::vector< rtl::OUString > 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() throw (); + + std::vector< rtl::OUString > directMandatoryBases_; + std::vector< rtl::OUString > directOptionalBases_; + std::vector< Attribute > directAttributes_; + std::vector< Method > directMethods_; +}; + +class LO_DLLPUBLIC_UNOIDL TypedefEntity: public PublishableEntity { +public: + SAL_DLLPRIVATE TypedefEntity(bool published, rtl::OUString const & type): + PublishableEntity(SORT_TYPEDEF, published), type_(type) + {} + + rtl::OUString getType() const { return type_; } + +private: + virtual SAL_DLLPRIVATE ~TypedefEntity() throw (); + + rtl::OUString type_; +}; + +struct 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 }; + + explicit ConstantValue(bool value): type(TYPE_BOOLEAN), booleanValue(value) + {} + + explicit ConstantValue(sal_Int8 value): type(TYPE_BYTE), byteValue(value) {} + + explicit ConstantValue(sal_Int16 value): type(TYPE_SHORT), shortValue(value) + {} + + explicit ConstantValue(sal_uInt16 value): + type(TYPE_UNSIGNED_SHORT), unsignedShortValue(value) + {} + + explicit ConstantValue(sal_Int32 value): type(TYPE_LONG), longValue(value) + {} + + explicit ConstantValue(sal_uInt32 value): + type(TYPE_UNSIGNED_LONG), unsignedLongValue(value) + {} + + explicit ConstantValue(sal_Int64 value): type(TYPE_HYPER), hyperValue(value) + {} + + explicit ConstantValue(sal_uInt64 value): + type(TYPE_UNSIGNED_HYPER), unsignedHyperValue(value) + {} + + explicit ConstantValue(float value): type(TYPE_FLOAT), floatValue(value) {} + + explicit 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 LO_DLLPUBLIC_UNOIDL ConstantGroupEntity: public PublishableEntity { +public: + struct Member { + Member(rtl::OUString const & theName, ConstantValue const & theValue): + name(theName), value(theValue) + {} + + rtl::OUString name; + + ConstantValue value; + }; + + SAL_DLLPRIVATE ConstantGroupEntity( + bool published, std::vector< Member > const & members): + PublishableEntity(SORT_CONSTANT_GROUP, published), members_(members) + {} + + std::vector< Member > const & getMembers() const { return members_; } + +private: + virtual SAL_DLLPRIVATE ~ConstantGroupEntity() throw (); + + std::vector< Member > members_; +}; + +class LO_DLLPUBLIC_UNOIDL SingleInterfaceBasedServiceEntity: + public PublishableEntity +{ +public: + struct Constructor { + struct Parameter { + Parameter( + rtl::OUString const & theName, rtl::OUString const & theType, + bool theRest): + name(theName), type(theType), rest(theRest) + {} + + rtl::OUString name; + + rtl::OUString type; + + bool rest; + }; + + Constructor(): defaultConstructor(true) {} + + Constructor( + rtl::OUString const & theName, + std::vector< Parameter > const & theParameters, + std::vector< rtl::OUString > const & theExceptions): + name(theName), parameters(theParameters), exceptions(theExceptions), + defaultConstructor(false) + {} + + rtl::OUString name; + + std::vector< Parameter > parameters; + + std::vector< rtl::OUString > exceptions; + + bool defaultConstructor; + }; + + SAL_DLLPRIVATE SingleInterfaceBasedServiceEntity( + bool published, rtl::OUString const & base, + std::vector< Constructor > const & constructors): + PublishableEntity(SORT_SINGLE_INTERFACE_BASED_SERVICE, published), + base_(base), constructors_(constructors) + {} + + rtl::OUString getBase() const { return base_; } + + std::vector< Constructor > const & getConstructors() const + { return constructors_; } + +private: + virtual SAL_DLLPRIVATE ~SingleInterfaceBasedServiceEntity() throw (); + + rtl::OUString base_; + std::vector< Constructor > constructors_; +}; + +class LO_DLLPUBLIC_UNOIDL AccumulationBasedServiceEntity: + 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( + rtl::OUString const & theName, rtl::OUString const & theType, + Attributes theAttributes): + name(theName), type(theType), attributes(theAttributes) + {} + + rtl::OUString name; + + rtl::OUString type; + + Attributes attributes; + }; + + SAL_DLLPRIVATE AccumulationBasedServiceEntity( + bool published, + std::vector< rtl::OUString > const & directMandatoryBaseServices, + std::vector< rtl::OUString > const & directOptionalBaseServices, + std::vector< rtl::OUString > const & directMandatoryBaseInterfaces, + std::vector< rtl::OUString > const & directOptionalBaseInterfaces, + std::vector< Property > const & directProperties): + PublishableEntity(SORT_ACCUMULATION_BASED_SERVICE, published), + directMandatoryBaseServices_(directMandatoryBaseServices), + directOptionalBaseServices_(directOptionalBaseServices), + directMandatoryBaseInterfaces_(directMandatoryBaseInterfaces), + directOptionalBaseInterfaces_(directOptionalBaseInterfaces), + directProperties_(directProperties) + {} + + std::vector< rtl::OUString > const & getDirectMandatoryBaseServices() const + { return directMandatoryBaseServices_; } + + std::vector< rtl::OUString > const & getDirectOptionalBaseServices() const + { return directOptionalBaseServices_; } + + std::vector< rtl::OUString > const & getDirectMandatoryBaseInterfaces() + const + { return directMandatoryBaseInterfaces_; } + + std::vector< rtl::OUString > const & getDirectOptionalBaseInterfaces() const + { return directOptionalBaseInterfaces_; } + + std::vector< Property > const & getDirectProperties() const + { return directProperties_; } + +private: + virtual SAL_DLLPRIVATE ~AccumulationBasedServiceEntity() throw (); + + std::vector< rtl::OUString > directMandatoryBaseServices_; + std::vector< rtl::OUString > directOptionalBaseServices_; + std::vector< rtl::OUString > directMandatoryBaseInterfaces_; + std::vector< rtl::OUString > directOptionalBaseInterfaces_; + std::vector< Property > directProperties_; +}; + +class LO_DLLPUBLIC_UNOIDL InterfaceBasedSingletonEntity: + public PublishableEntity +{ +public: + SAL_DLLPRIVATE InterfaceBasedSingletonEntity( + bool published, rtl::OUString const & base): + PublishableEntity(SORT_INTERFACE_BASED_SINGLETON, published), + base_(base) + {} + + rtl::OUString getBase() const { return base_; } + +private: + virtual SAL_DLLPRIVATE ~InterfaceBasedSingletonEntity() throw (); + + rtl::OUString base_; +}; + +class LO_DLLPUBLIC_UNOIDL ServiceBasedSingletonEntity: public PublishableEntity +{ +public: + SAL_DLLPRIVATE ServiceBasedSingletonEntity( + bool published, rtl::OUString const & base): + PublishableEntity(SORT_SERVICE_BASED_SINGLETON, published), base_(base) + {} + + rtl::OUString getBase() const { return base_; } + +private: + virtual SAL_DLLPRIVATE ~ServiceBasedSingletonEntity() throw (); + + rtl::OUString base_; +}; + +class LO_DLLPUBLIC_UNOIDL Provider: public salhelper::SimpleReferenceObject { +public: + // throws FileFormatException: + virtual rtl::Reference< MapCursor > createRootCursor() const = 0; + + // throws FileFormatException: + virtual rtl::Reference< Entity > findEntity(rtl::OUString const & name) + const = 0; + +protected: + SAL_DLLPRIVATE Provider() {} + + virtual SAL_DLLPRIVATE ~Provider() throw (); +}; + +class LO_DLLPUBLIC_UNOIDL Manager: public salhelper::SimpleReferenceObject { +public: + Manager() {} + + void addProvider(rtl::Reference< Provider > const & provider); + + // throws FileFormatException: + rtl::Reference< Entity > findEntity(rtl::OUString const & name) const; + + // throws FileFormatException: + rtl::Reference< MapCursor > createCursor(rtl::OUString const & name) const; + +private: + virtual SAL_DLLPRIVATE ~Manager() throw (); + + mutable osl::Mutex mutex_; + std::vector< rtl::Reference< Provider > > providers_; +}; + +// throws FileFormatException, NoSuchFileException: +LO_DLLPUBLIC_UNOIDL rtl::Reference< Provider > loadProvider( + rtl::Reference< Manager > const & manager, rtl::OUString const & uri); + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |