LCOV - code coverage report
Current view: top level - include/unoidl - unoidl.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 39 152 25.7 %
Date: 2014-04-14 Functions: 29 106 27.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  */
       9             : 
      10             : #ifndef INCLUDED_UNOIDL_UNOIDL_HXX
      11             : #define INCLUDED_UNOIDL_UNOIDL_HXX
      12             : 
      13             : #include <sal/config.h>
      14             : 
      15             : #include <cassert>
      16             : #include <vector>
      17             : 
      18             : #include <osl/mutex.hxx>
      19             : #include <rtl/ref.hxx>
      20             : #include <rtl/ustring.hxx>
      21             : #include <sal/types.h>
      22             : #include <salhelper/simplereferenceobject.hxx>
      23             : #include <unoidl/detail/dllapi.hxx>
      24             : 
      25             : namespace unoidl {
      26             : 
      27             : class LO_DLLPUBLIC_UNOIDL NoSuchFileException {
      28             : public:
      29           0 :     SAL_DLLPRIVATE NoSuchFileException(rtl::OUString const & uri): uri_(uri) {}
      30             : 
      31             :     SAL_DLLPRIVATE NoSuchFileException(NoSuchFileException const & other):
      32             :         uri_(other.uri_) {}
      33             : 
      34             :     virtual SAL_DLLPRIVATE ~NoSuchFileException() throw ();
      35             : 
      36           0 :     rtl::OUString getUri() const { return uri_; }
      37             : 
      38             : private:
      39             :     void operator =(NoSuchFileException) SAL_DELETED_FUNCTION;
      40             : 
      41             :     rtl::OUString uri_;
      42             : };
      43             : 
      44             : class LO_DLLPUBLIC_UNOIDL FileFormatException {
      45             : public:
      46           0 :     SAL_DLLPRIVATE FileFormatException(
      47             :         rtl::OUString const & uri, rtl::OUString const & detail):
      48           0 :         uri_(uri), detail_(detail)
      49           0 :     {}
      50             : 
      51             :     SAL_DLLPRIVATE FileFormatException(FileFormatException const & other):
      52             :         uri_(other.uri_), detail_(other.detail_)
      53             :     {}
      54             : 
      55             :     virtual SAL_DLLPRIVATE ~FileFormatException() throw ();
      56             : 
      57           0 :     rtl::OUString getUri() const { return uri_; }
      58             : 
      59           0 :     rtl::OUString getDetail() const { return detail_; }
      60             : 
      61             : private:
      62             :     void operator =(FileFormatException) SAL_DELETED_FUNCTION;
      63             : 
      64             :     rtl::OUString uri_;
      65             :     rtl::OUString detail_;
      66             : };
      67             : 
      68          15 : struct AnnotatedReference {
      69           3 :     AnnotatedReference(
      70             :         rtl::OUString const & theName,
      71             :         std::vector< rtl::OUString > const & theAnnotations):
      72           3 :         name(theName), annotations(theAnnotations)
      73           3 :     {}
      74             : 
      75             :     rtl::OUString name;
      76             : 
      77             :     std::vector< rtl::OUString > annotations;
      78             : };
      79             : 
      80             : class LO_DLLPUBLIC_UNOIDL Entity: public salhelper::SimpleReferenceObject {
      81             : public:
      82             :     enum Sort {
      83             :         SORT_MODULE, SORT_ENUM_TYPE, SORT_PLAIN_STRUCT_TYPE,
      84             :         SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, SORT_EXCEPTION_TYPE,
      85             :         SORT_INTERFACE_TYPE, SORT_TYPEDEF, SORT_CONSTANT_GROUP,
      86             :         SORT_SINGLE_INTERFACE_BASED_SERVICE, SORT_ACCUMULATION_BASED_SERVICE,
      87             :         SORT_INTERFACE_BASED_SINGLETON, SORT_SERVICE_BASED_SINGLETON
      88             :     };
      89             : 
      90          11 :     Sort getSort() const { return sort_; }
      91             : 
      92             : protected:
      93          11 :     explicit SAL_DLLPRIVATE Entity(Sort sort): sort_(sort) {}
      94             : 
      95             :     virtual SAL_DLLPRIVATE ~Entity() throw ();
      96             : 
      97             : private:
      98             :     Sort sort_;
      99             : };
     100             : 
     101             : class LO_DLLPUBLIC_UNOIDL MapCursor: public salhelper::SimpleReferenceObject {
     102             : public:
     103             :     // throws FileFormatException:
     104             :     virtual rtl::Reference< Entity > getNext(rtl::OUString * name) = 0;
     105             : 
     106             : protected:
     107           0 :     SAL_DLLPRIVATE MapCursor() {}
     108             : 
     109             :     virtual SAL_DLLPRIVATE ~MapCursor() throw();
     110             : };
     111             : 
     112             : class LO_DLLPUBLIC_UNOIDL ModuleEntity: public Entity {
     113             : public:
     114             :     // throws FileFormatException:
     115             :     virtual std::vector< rtl::OUString > getMemberNames() const = 0;
     116             : 
     117             :     // throws FileFormatException:
     118             :     virtual rtl::Reference< MapCursor > createCursor() const = 0;
     119             : 
     120             : protected:
     121           0 :     SAL_DLLPRIVATE ModuleEntity(): Entity(SORT_MODULE) {}
     122             : 
     123             :     virtual SAL_DLLPRIVATE ~ModuleEntity() throw ();
     124             : };
     125             : 
     126             : class LO_DLLPUBLIC_UNOIDL PublishableEntity: public Entity {
     127             : public:
     128          10 :     bool isPublished() const { return published_; }
     129             : 
     130           0 :     std::vector< rtl::OUString > const & getAnnotations() const
     131           0 :     { return annotations_; }
     132             : 
     133             : protected:
     134          11 :     SAL_DLLPRIVATE PublishableEntity(
     135             :         Sort sort, bool published,
     136             :         std::vector< rtl::OUString > const & annotations):
     137          11 :         Entity(sort), published_(published), annotations_(annotations)
     138          11 :     {}
     139             : 
     140             :     virtual SAL_DLLPRIVATE ~PublishableEntity() throw ();
     141             : 
     142             : private:
     143             :     bool published_;
     144             : 
     145             :     std::vector< rtl::OUString > annotations_;
     146             : };
     147             : 
     148             : class LO_DLLPUBLIC_UNOIDL EnumTypeEntity: public PublishableEntity {
     149             : public:
     150           0 :     struct Member {
     151           0 :         Member(
     152             :             rtl::OUString const & theName, sal_Int32 theValue,
     153             :             std::vector< rtl::OUString > const & theAnnotations):
     154           0 :             name(theName), value(theValue), annotations(theAnnotations)
     155           0 :         {}
     156             : 
     157             :         rtl::OUString name;
     158             : 
     159             :         sal_Int32 value;
     160             : 
     161             :         std::vector< rtl::OUString > annotations;
     162             :     };
     163             : 
     164           0 :     SAL_DLLPRIVATE EnumTypeEntity(
     165             :         bool published, std::vector< Member > const & members,
     166             :         std::vector< rtl::OUString > const & annotations):
     167             :         PublishableEntity(SORT_ENUM_TYPE, published, annotations),
     168           0 :         members_(members)
     169           0 :     { assert(!members.empty()); }
     170             : 
     171           0 :     std::vector< Member > const & getMembers() const { return members_; }
     172             : 
     173             : private:
     174             :     virtual SAL_DLLPRIVATE ~EnumTypeEntity() throw ();
     175             : 
     176             :     std::vector< Member > members_;
     177             : };
     178             : 
     179             : class LO_DLLPUBLIC_UNOIDL PlainStructTypeEntity: public PublishableEntity {
     180             : public:
     181           0 :     struct Member {
     182           0 :         Member(rtl::OUString const & theName, rtl::OUString const & theType,
     183             :                std::vector< rtl::OUString > const & theAnnotations):
     184           0 :             name(theName), type(theType), annotations(theAnnotations)
     185           0 :         {}
     186             : 
     187             :         rtl::OUString name;
     188             : 
     189             :         rtl::OUString type;
     190             : 
     191             :         std::vector< rtl::OUString > annotations;
     192             :     };
     193             : 
     194           0 :     SAL_DLLPRIVATE PlainStructTypeEntity(
     195             :         bool published, rtl::OUString const & directBase,
     196             :         std::vector< Member > const & directMembers,
     197             :         std::vector< rtl::OUString > const & annotations):
     198             :         PublishableEntity(SORT_PLAIN_STRUCT_TYPE, published, annotations),
     199           0 :         directBase_(directBase), directMembers_(directMembers)
     200           0 :     {}
     201             : 
     202           0 :     rtl::OUString getDirectBase() const { return directBase_; }
     203             : 
     204           0 :     std::vector< Member > const & getDirectMembers() const
     205           0 :     { return directMembers_; }
     206             : 
     207             : private:
     208             :     virtual SAL_DLLPRIVATE ~PlainStructTypeEntity() throw ();
     209             : 
     210             :     rtl::OUString directBase_;
     211             :     std::vector< Member > directMembers_;
     212             : };
     213             : 
     214             : class LO_DLLPUBLIC_UNOIDL PolymorphicStructTypeTemplateEntity:
     215             :     public PublishableEntity
     216             : {
     217             : public:
     218          24 :     struct Member {
     219           4 :         Member(
     220             :             rtl::OUString const & theName, rtl::OUString const & theType,
     221             :             bool theParameterized,
     222             :             std::vector< rtl::OUString > const & theAnnotations):
     223             :             name(theName), type(theType), parameterized(theParameterized),
     224           4 :             annotations(theAnnotations)
     225           4 :         {}
     226             : 
     227             :         rtl::OUString name;
     228             : 
     229             :         rtl::OUString type;
     230             : 
     231             :         bool parameterized;
     232             : 
     233             :         std::vector< rtl::OUString > annotations;
     234             :     };
     235             : 
     236           2 :     SAL_DLLPRIVATE PolymorphicStructTypeTemplateEntity(
     237             :         bool published, std::vector< rtl::OUString > const & typeParameters,
     238             :         std::vector< Member > const & members,
     239             :         std::vector< rtl::OUString > const & annotations):
     240             :         PublishableEntity(
     241             :             SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, published, annotations),
     242           2 :         typeParameters_(typeParameters), members_(members)
     243           2 :     {}
     244             : 
     245           4 :     std::vector< rtl::OUString > const & getTypeParameters() const
     246           4 :     { return typeParameters_; }
     247             : 
     248          13 :     std::vector< Member > const & getMembers() const { return members_; }
     249             : 
     250             : private:
     251             :     virtual SAL_DLLPRIVATE ~PolymorphicStructTypeTemplateEntity() throw ();
     252             : 
     253             :     std::vector< rtl::OUString > typeParameters_;
     254             :     std::vector< Member > members_;
     255             : };
     256             : 
     257             : class LO_DLLPUBLIC_UNOIDL ExceptionTypeEntity: public PublishableEntity {
     258             : public:
     259           0 :     struct Member {
     260           0 :         Member(
     261             :             rtl::OUString const & theName, rtl::OUString const & theType,
     262             :             std::vector< rtl::OUString > const & theAnnotations):
     263           0 :             name(theName), type(theType), annotations(theAnnotations)
     264           0 :         {}
     265             : 
     266             :         rtl::OUString name;
     267             : 
     268             :         rtl::OUString type;
     269             : 
     270             :         std::vector< rtl::OUString > annotations;
     271             :     };
     272             : 
     273           0 :     SAL_DLLPRIVATE ExceptionTypeEntity(
     274             :         bool published, rtl::OUString const & directBase,
     275             :         std::vector< Member > const & directMembers,
     276             :         std::vector< rtl::OUString > const & annotations):
     277             :         PublishableEntity(SORT_EXCEPTION_TYPE, published, annotations),
     278           0 :         directBase_(directBase), directMembers_(directMembers)
     279           0 :     {}
     280             : 
     281           0 :     rtl::OUString getDirectBase() const { return directBase_; }
     282             : 
     283           0 :     std::vector< Member > const & getDirectMembers() const
     284           0 :     { return directMembers_; }
     285             : 
     286             : private:
     287             :     virtual SAL_DLLPRIVATE ~ExceptionTypeEntity() throw ();
     288             : 
     289             :     rtl::OUString directBase_;
     290             :     std::vector< Member > directMembers_;
     291             : };
     292             : 
     293             : class LO_DLLPUBLIC_UNOIDL InterfaceTypeEntity: public PublishableEntity {
     294             : public:
     295           0 :     struct Attribute {
     296           0 :         Attribute(
     297             :             rtl::OUString const & theName, rtl::OUString const & theType,
     298             :             bool theBound, bool theReadOnly,
     299             :             std::vector< rtl::OUString > const & theGetExceptions,
     300             :             std::vector< rtl::OUString > const & theSetExceptions,
     301             :             std::vector< rtl::OUString > const & theAnnotations):
     302             :             name(theName), type(theType), bound(theBound),
     303             :             readOnly(theReadOnly), getExceptions(theGetExceptions),
     304           0 :             setExceptions(theSetExceptions), annotations(theAnnotations)
     305           0 :         { assert(!theReadOnly || theSetExceptions.empty()); }
     306             : 
     307             :         rtl::OUString name;
     308             : 
     309             :         rtl::OUString type;
     310             : 
     311             :         bool bound;
     312             : 
     313             :         bool readOnly;
     314             : 
     315             :         std::vector< rtl::OUString > getExceptions;
     316             : 
     317             :         std::vector< rtl::OUString > setExceptions;
     318             : 
     319             :         std::vector< rtl::OUString > annotations;
     320             :     };
     321             : 
     322         232 :     struct Method {
     323         129 :         struct Parameter {
     324             :             enum Direction { DIRECTION_IN, DIRECTION_OUT, DIRECTION_IN_OUT };
     325             : 
     326          11 :             Parameter(
     327             :                 rtl::OUString const & theName, rtl::OUString const & theType,
     328             :                 Direction theDirection):
     329          11 :                 name(theName), type(theType), direction(theDirection)
     330          11 :             {}
     331             : 
     332             :             rtl::OUString name;
     333             : 
     334             :             rtl::OUString type;
     335             : 
     336             :             Direction direction;
     337             :         };
     338             : 
     339          26 :         Method(
     340             :             rtl::OUString const & theName, rtl::OUString const & theReturnType,
     341             :             std::vector< Parameter > const & theParameters,
     342             :             std::vector< rtl::OUString > const & theExceptions,
     343             :             std::vector< rtl::OUString > const & theAnnotations):
     344             :             name(theName), returnType(theReturnType), parameters(theParameters),
     345          26 :             exceptions(theExceptions), annotations(theAnnotations)
     346          26 :         {}
     347             : 
     348             :         rtl::OUString name;
     349             : 
     350             :         rtl::OUString returnType;
     351             : 
     352             :         std::vector< Parameter > parameters;
     353             : 
     354             :         std::vector< rtl::OUString > exceptions;
     355             : 
     356             :         std::vector< rtl::OUString > annotations;
     357             :     };
     358             : 
     359           9 :     SAL_DLLPRIVATE InterfaceTypeEntity(
     360             :         bool published,
     361             :         std::vector< AnnotatedReference > const & directMandatoryBases,
     362             :         std::vector< AnnotatedReference > const & directOptionalBases,
     363             :         std::vector< Attribute > const & directAttributes,
     364             :         std::vector< Method > const & directMethods,
     365             :         std::vector< rtl::OUString > const & annotations):
     366             :         PublishableEntity(SORT_INTERFACE_TYPE, published, annotations),
     367             :         directMandatoryBases_(directMandatoryBases),
     368             :         directOptionalBases_(directOptionalBases),
     369           9 :         directAttributes_(directAttributes), directMethods_(directMethods)
     370           9 :     {}
     371             : 
     372          24 :     std::vector< AnnotatedReference > const & getDirectMandatoryBases() const
     373          24 :     { return directMandatoryBases_; }
     374             : 
     375           0 :     std::vector< AnnotatedReference > const & getDirectOptionalBases() const
     376           0 :     { return directOptionalBases_; }
     377             : 
     378           9 :     std::vector< Attribute > const & getDirectAttributes() const
     379           9 :     { return directAttributes_; }
     380             : 
     381          61 :     std::vector< Method > const & getDirectMethods() const
     382          61 :     { return directMethods_; }
     383             : 
     384             : private:
     385             :     virtual SAL_DLLPRIVATE ~InterfaceTypeEntity() throw ();
     386             : 
     387             :     std::vector< AnnotatedReference > directMandatoryBases_;
     388             :     std::vector< AnnotatedReference > directOptionalBases_;
     389             :     std::vector< Attribute > directAttributes_;
     390             :     std::vector< Method > directMethods_;
     391             : };
     392             : 
     393             : class LO_DLLPUBLIC_UNOIDL TypedefEntity: public PublishableEntity {
     394             : public:
     395           0 :     SAL_DLLPRIVATE TypedefEntity(
     396             :         bool published, rtl::OUString const & type,
     397             :         std::vector< rtl::OUString > const & annotations):
     398           0 :         PublishableEntity(SORT_TYPEDEF, published, annotations), type_(type)
     399           0 :     {}
     400             : 
     401           0 :     rtl::OUString getType() const { return type_; }
     402             : 
     403             : private:
     404             :     virtual SAL_DLLPRIVATE ~TypedefEntity() throw ();
     405             : 
     406             :     rtl::OUString type_;
     407             : };
     408             : 
     409             : struct LO_DLLPUBLIC_UNOIDL ConstantValue {
     410             :     enum Type {
     411             :         TYPE_BOOLEAN, TYPE_BYTE, TYPE_SHORT, TYPE_UNSIGNED_SHORT, TYPE_LONG,
     412             :         TYPE_UNSIGNED_LONG, TYPE_HYPER, TYPE_UNSIGNED_HYPER, TYPE_FLOAT,
     413             :         TYPE_DOUBLE };
     414             : 
     415           0 :     ConstantValue(bool value): type(TYPE_BOOLEAN), booleanValue(value) {}
     416             : 
     417           0 :     ConstantValue(sal_Int8 value): type(TYPE_BYTE), byteValue(value) {}
     418             : 
     419           0 :     ConstantValue(sal_Int16 value): type(TYPE_SHORT), shortValue(value) {}
     420             : 
     421           0 :     ConstantValue(sal_uInt16 value):
     422           0 :         type(TYPE_UNSIGNED_SHORT), unsignedShortValue(value)
     423           0 :     {}
     424             : 
     425           0 :     ConstantValue(sal_Int32 value): type(TYPE_LONG), longValue(value) {}
     426             : 
     427           0 :     ConstantValue(sal_uInt32 value):
     428           0 :         type(TYPE_UNSIGNED_LONG), unsignedLongValue(value)
     429           0 :     {}
     430             : 
     431           0 :     ConstantValue(sal_Int64 value): type(TYPE_HYPER), hyperValue(value) {}
     432             : 
     433           0 :     ConstantValue(sal_uInt64 value):
     434           0 :         type(TYPE_UNSIGNED_HYPER), unsignedHyperValue(value)
     435           0 :     {}
     436             : 
     437           0 :     ConstantValue(float value): type(TYPE_FLOAT), floatValue(value) {}
     438             : 
     439           0 :     ConstantValue(double value): type(TYPE_DOUBLE), doubleValue(value) {}
     440             : 
     441             :     Type type;
     442             : 
     443             :     union {
     444             :         bool booleanValue;
     445             :         sal_Int8 byteValue;
     446             :         sal_Int16 shortValue;
     447             :         sal_uInt16 unsignedShortValue;
     448             :         sal_Int32 longValue;
     449             :         sal_uInt32 unsignedLongValue;
     450             :         sal_Int64 hyperValue;
     451             :         sal_uInt64 unsignedHyperValue;
     452             :         float floatValue;
     453             :         double doubleValue;
     454             :     };
     455             : };
     456             : 
     457             : class LO_DLLPUBLIC_UNOIDL ConstantGroupEntity: public PublishableEntity {
     458             : public:
     459           0 :     struct Member {
     460           0 :         Member(
     461             :             rtl::OUString const & theName, ConstantValue const & theValue,
     462             :             std::vector< rtl::OUString > const & theAnnotations):
     463           0 :             name(theName), value(theValue), annotations(theAnnotations)
     464           0 :         {}
     465             : 
     466             :         rtl::OUString name;
     467             : 
     468             :         ConstantValue value;
     469             : 
     470             :         std::vector< rtl::OUString > annotations;
     471             :     };
     472             : 
     473           0 :     SAL_DLLPRIVATE ConstantGroupEntity(
     474             :         bool published, std::vector< Member > const & members,
     475             :         std::vector< rtl::OUString > const & annotations):
     476             :         PublishableEntity(SORT_CONSTANT_GROUP, published, annotations),
     477           0 :         members_(members)
     478           0 :     {}
     479             : 
     480           0 :     std::vector< Member > const & getMembers() const { return members_; }
     481             : 
     482             : private:
     483             :     virtual SAL_DLLPRIVATE ~ConstantGroupEntity() throw ();
     484             : 
     485             :     std::vector< Member > members_;
     486             : };
     487             : 
     488             : class LO_DLLPUBLIC_UNOIDL SingleInterfaceBasedServiceEntity:
     489             :     public PublishableEntity
     490             : {
     491             : public:
     492           0 :     struct Constructor {
     493           0 :         struct Parameter {
     494           0 :             Parameter(
     495             :                 rtl::OUString const & theName, rtl::OUString const & theType,
     496             :                 bool theRest):
     497           0 :                 name(theName), type(theType), rest(theRest)
     498           0 :             {}
     499             : 
     500             :             rtl::OUString name;
     501             : 
     502             :             rtl::OUString type;
     503             : 
     504             :             bool rest;
     505             :         };
     506             : 
     507           0 :         Constructor(): defaultConstructor(true) {}
     508             : 
     509           0 :         Constructor(
     510             :             rtl::OUString const & theName,
     511             :             std::vector< Parameter > const & theParameters,
     512             :             std::vector< rtl::OUString > const & theExceptions,
     513             :             std::vector< rtl::OUString > const & theAnnotations):
     514             :             name(theName), parameters(theParameters), exceptions(theExceptions),
     515           0 :             annotations(theAnnotations), defaultConstructor(false)
     516           0 :         {}
     517             : 
     518             :         rtl::OUString name;
     519             : 
     520             :         std::vector< Parameter > parameters;
     521             : 
     522             :         std::vector< rtl::OUString > exceptions;
     523             : 
     524             :         std::vector< rtl::OUString > annotations;
     525             : 
     526             :         bool defaultConstructor;
     527             :     };
     528             : 
     529           0 :     SAL_DLLPRIVATE SingleInterfaceBasedServiceEntity(
     530             :         bool published, rtl::OUString const & base,
     531             :         std::vector< Constructor > const & constructors,
     532             :         std::vector< rtl::OUString > const & annotations):
     533             :         PublishableEntity(
     534             :             SORT_SINGLE_INTERFACE_BASED_SERVICE, published, annotations),
     535           0 :         base_(base), constructors_(constructors)
     536           0 :     {}
     537             : 
     538           0 :     rtl::OUString getBase() const { return base_; }
     539             : 
     540           0 :     std::vector< Constructor > const & getConstructors() const
     541           0 :     { return constructors_; }
     542             : 
     543             : private:
     544             :     virtual SAL_DLLPRIVATE ~SingleInterfaceBasedServiceEntity() throw ();
     545             : 
     546             :     rtl::OUString base_;
     547             :     std::vector< Constructor > constructors_;
     548             : };
     549             : 
     550             : class LO_DLLPUBLIC_UNOIDL AccumulationBasedServiceEntity:
     551             :     public PublishableEntity
     552             : {
     553             : public:
     554           0 :     struct Property {
     555             :         enum Attributes {
     556             :             ATTRIBUTE_MAYBE_VOID = 0x001,
     557             :             ATTRIBUTE_BOUND = 0x002,
     558             :             ATTRIBUTE_CONSTRAINED = 0x004,
     559             :             ATTRIBUTE_TRANSIENT = 0x008,
     560             :             ATTRIBUTE_READ_ONLY = 0x010,
     561             :             ATTRIBUTE_MAYBE_AMBIGUOUS = 0x020,
     562             :             ATTRIBUTE_MAYBE_DEFAULT = 0x040,
     563             :             ATTRIBUTE_REMOVABLE = 0x080,
     564             :             ATTRIBUTE_OPTIONAL = 0x100
     565             :         };
     566             : 
     567           0 :         Property(
     568             :             rtl::OUString const & theName, rtl::OUString const & theType,
     569             :             Attributes theAttributes,
     570             :             std::vector< rtl::OUString > const & theAnnotations):
     571             :             name(theName), type(theType), attributes(theAttributes),
     572           0 :             annotations(theAnnotations)
     573           0 :         {}
     574             : 
     575             :         rtl::OUString name;
     576             : 
     577             :         rtl::OUString type;
     578             : 
     579             :         Attributes attributes;
     580             : 
     581             :         std::vector< rtl::OUString > annotations;
     582             :     };
     583             : 
     584           0 :     SAL_DLLPRIVATE AccumulationBasedServiceEntity(
     585             :         bool published,
     586             :         std::vector< AnnotatedReference > const & directMandatoryBaseServices,
     587             :         std::vector< AnnotatedReference > const & directOptionalBaseServices,
     588             :         std::vector< AnnotatedReference > const & directMandatoryBaseInterfaces,
     589             :         std::vector< AnnotatedReference > const & directOptionalBaseInterfaces,
     590             :         std::vector< Property > const & directProperties,
     591             :         std::vector< rtl::OUString > const & annotations):
     592             :         PublishableEntity(
     593             :             SORT_ACCUMULATION_BASED_SERVICE, published, annotations),
     594             :         directMandatoryBaseServices_(directMandatoryBaseServices),
     595             :         directOptionalBaseServices_(directOptionalBaseServices),
     596             :         directMandatoryBaseInterfaces_(directMandatoryBaseInterfaces),
     597             :         directOptionalBaseInterfaces_(directOptionalBaseInterfaces),
     598           0 :         directProperties_(directProperties)
     599           0 :         {}
     600             : 
     601           0 :     std::vector< AnnotatedReference > const & getDirectMandatoryBaseServices()
     602             :         const
     603           0 :     { return directMandatoryBaseServices_; }
     604             : 
     605           0 :     std::vector< AnnotatedReference > const & getDirectOptionalBaseServices()
     606             :         const
     607           0 :     { return directOptionalBaseServices_; }
     608             : 
     609           0 :     std::vector< AnnotatedReference > const & getDirectMandatoryBaseInterfaces()
     610             :         const
     611           0 :     { return directMandatoryBaseInterfaces_; }
     612             : 
     613           0 :     std::vector< AnnotatedReference > const & getDirectOptionalBaseInterfaces()
     614             :         const
     615           0 :     { return directOptionalBaseInterfaces_; }
     616             : 
     617           0 :     std::vector< Property > const & getDirectProperties() const
     618           0 :     { return directProperties_; }
     619             : 
     620             : private:
     621             :     virtual SAL_DLLPRIVATE ~AccumulationBasedServiceEntity() throw ();
     622             : 
     623             :     std::vector< AnnotatedReference > directMandatoryBaseServices_;
     624             :     std::vector< AnnotatedReference > directOptionalBaseServices_;
     625             :     std::vector< AnnotatedReference > directMandatoryBaseInterfaces_;
     626             :     std::vector< AnnotatedReference > directOptionalBaseInterfaces_;
     627             :     std::vector< Property > directProperties_;
     628             : };
     629             : 
     630             : class LO_DLLPUBLIC_UNOIDL InterfaceBasedSingletonEntity:
     631             :     public PublishableEntity
     632             : {
     633             : public:
     634           0 :     SAL_DLLPRIVATE InterfaceBasedSingletonEntity(
     635             :         bool published, rtl::OUString const & base,
     636             :         std::vector< rtl::OUString > const & annotations):
     637             :         PublishableEntity(
     638             :             SORT_INTERFACE_BASED_SINGLETON, published, annotations),
     639           0 :         base_(base)
     640           0 :     {}
     641             : 
     642           0 :     rtl::OUString getBase() const { return base_; }
     643             : 
     644             : private:
     645             :     virtual SAL_DLLPRIVATE ~InterfaceBasedSingletonEntity() throw ();
     646             : 
     647             :     rtl::OUString base_;
     648             : };
     649             : 
     650             : class LO_DLLPUBLIC_UNOIDL ServiceBasedSingletonEntity: public PublishableEntity
     651             : {
     652             : public:
     653           0 :     SAL_DLLPRIVATE ServiceBasedSingletonEntity(
     654             :         bool published, rtl::OUString const & base,
     655             :         std::vector< rtl::OUString > const & annotations):
     656             :         PublishableEntity(SORT_SERVICE_BASED_SINGLETON, published, annotations),
     657           0 :         base_(base)
     658           0 :     {}
     659             : 
     660           0 :     rtl::OUString getBase() const { return base_; }
     661             : 
     662             : private:
     663             :     virtual SAL_DLLPRIVATE ~ServiceBasedSingletonEntity() throw ();
     664             : 
     665             :     rtl::OUString base_;
     666             : };
     667             : 
     668             : class LO_DLLPUBLIC_UNOIDL Provider: public salhelper::SimpleReferenceObject {
     669             : public:
     670             :     // throws FileFormatException:
     671             :     virtual rtl::Reference< MapCursor > createRootCursor() const = 0;
     672             : 
     673             :     // throws FileFormatException:
     674             :     virtual rtl::Reference< Entity > findEntity(rtl::OUString const & name)
     675             :         const = 0;
     676             : 
     677             : protected:
     678           3 :     SAL_DLLPRIVATE Provider() {}
     679             : 
     680             :     virtual SAL_DLLPRIVATE ~Provider() throw ();
     681             : };
     682             : 
     683             : class LO_DLLPUBLIC_UNOIDL Manager: public salhelper::SimpleReferenceObject {
     684             : public:
     685           1 :     Manager() {}
     686             : 
     687             :     void addProvider(rtl::Reference< Provider > const & provider);
     688             : 
     689             :     // throws FileFormatException:
     690             :     rtl::Reference< Entity > findEntity(rtl::OUString const & name) const;
     691             : 
     692             :     // throws FileFormatException:
     693             :     rtl::Reference< MapCursor > createCursor(rtl::OUString const & name) const;
     694             : 
     695             : private:
     696             :     virtual SAL_DLLPRIVATE ~Manager() throw ();
     697             : 
     698             :     mutable osl::Mutex mutex_;
     699             :     std::vector< rtl::Reference< Provider > > providers_;
     700             : };
     701             : 
     702             : // throws FileFormatException, NoSuchFileException:
     703             : LO_DLLPUBLIC_UNOIDL rtl::Reference< Provider > loadProvider(
     704             :     rtl::Reference< Manager > const & manager, rtl::OUString const & uri);
     705             : 
     706             : }
     707             : 
     708             : #endif
     709             : 
     710             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10