include/registry/types.h

   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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_registry_types_h
  21 #define INCLUDED_registry_types_h
  22
  23 #include "sal/types.h"
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 /** specifies the typeclass of a binary type blob.
  30
  31     The general structure of a binary type blob is always the same.  It depends
  32     on the typeclass which parts of the blob are filled with data or not.
  33  */
  34 enum RTTypeClass {
  35     /** specifies that the structure of the given blob is unknown and can't be
  36         read.
  37      */
  38     RT_TYPE_INVALID,
  39
  40     /** specifies that the blob represents an interface type.  An interface blob
  41         can contain a base interface, attributes and methods.
  42      */
  43     RT_TYPE_INTERFACE,
  44
  45     /** specifies that the blob represents a module type.  A module blob can
  46         contain a base module and constant members (fields).
  47      */
  48     RT_TYPE_MODULE,
  49
  50     /** specifies that the blob represents a struct type.  A struct blob can
  51         contain a base struct and members (fields).
  52      */
  53     RT_TYPE_STRUCT,
  54
  55     /** specifies that the blob represents an enum type.  An enum blob can
  56         contain enum values which are accessible as fields.
  57      */
  58     RT_TYPE_ENUM,
  59
  60     /** specifies that the blob represents an exception type.  An exception blob
  61         can contain a base exception and members (fields).
  62      */
  63     RT_TYPE_EXCEPTION,
  64
  65     /** specifies that the blob represents a typedef type.  A typedef blob can
  66         contain a base type.
  67      */
  68     RT_TYPE_TYPEDEF,
  69
  70     /** specifies that the blob represents a service type.  A service blob can
  71         contain a base service, properties (fields), references to services or
  72         interfaces.
  73      */
  74     RT_TYPE_SERVICE,
  75
  76     /** specifies that the blob represents a singleton type (a named object)
  77         which refers exactly one existing service.
  78      */
  79     RT_TYPE_SINGLETON,
  80
  81     /// deprecated, not used.
  82     RT_TYPE_OBJECT,
  83
  84     /** specifies that the blob represents a constants type.  A constants blob
  85         can contain constant types as fields.
  86      */
  87     RT_TYPE_CONSTANTS,
  88
  89     /** @deprecated
  90         a union type was evaluated but currently not supported.
  91      */
  92     RT_TYPE_UNION,
  93
  94     /// @cond INTERNAL
  95     /**
  96        Flag for published entities.
  97
  98        Used in combination with RT_TYPE_INTERFACE, RT_TYPE_STRUCT, RT_TYPE_ENUM,
  99        RT_TYPE_EXCEPTION, RT_TYPE_TYPEDEF, RT_TYPE_SERVICE, RT_TYPE_SINGLETON,
 100        or RT_TYPE_CONSTANTS to mark an entity as published.
 101
 102        (The value of this enumerator is chosen so that it is unlikely that its
 103        addition changes the underlying type of this enumeration for any C/C++
 104        compiler.)
 105
 106        @since UDK 3.2.0
 107      */
 108     RT_TYPE_PUBLISHED = 0x4000
 109     /// @endcond
 110 };
 111
 112 /** specifies the type for the field access.
 113
 114     Fields in a type blob are used for different types.  Among others they were
 115     used for properties of services and these poperties can have several flags.
 116
 117     @see RT_ACCESS_INVALID
 118     @see RT_ACCESS_READONLY
 119     @see RT_ACCESS_OPTIONAL
 120     @see RT_ACCESS_MAYBEVOID
 121     @see RT_ACCESS_BOUND
 122     @see RT_ACCESS_CONSTRAINED
 123     @see RT_ACCESS_TRANSIENT
 124     @see RT_ACCESS_MAYBEAMBIGUOUS
 125     @see RT_ACCESS_MAYBEDEFAULT
 126     @see RT_ACCESS_REMOVEABLE
 127     @see RT_ACCESS_ATTRIBUTE
 128     @see RT_ACCESS_PROPERTY
 129     @see RT_ACCESS_CONST
 130     @see RT_ACCESS_READWRITE
 131     @see RT_ACCESS_DEFAULT
 132     @see RT_ACCESS_PARAMETERIZED_TYPE
 133     @see RT_ACCESS_PUBLISHED
 134  */
 135 typedef sal_uInt16 RTFieldAccess;
 136
 137 /// specifies a unknown flag
 138 #define RT_ACCESS_INVALID 0x0000
 139 /// specifies a readonly property/attribute
 140 #define RT_ACCESS_READONLY 0x0001
 141 /// specifies a property as optional that means that it must not be implemented.
 142 #define RT_ACCESS_OPTIONAL 0x0002
 143 /// @see com::sun::star::beans::PropertyAttribute
 144 #define RT_ACCESS_MAYBEVOID 0x0004
 145 /// @see com::sun::star::beans::PropertyAttribute
 146 #define RT_ACCESS_BOUND 0x0008
 147 /// @see com::sun::star::beans::PropertyAttribute
 148 #define RT_ACCESS_CONSTRAINED 0x0010
 149 /// @see com::sun::star::beans::PropertyAttribute
 150 #define RT_ACCESS_TRANSIENT 0x0020
 151 /// @see com::sun::star::beans::PropertyAttribute
 152 #define RT_ACCESS_MAYBEAMBIGUOUS 0x0040
 153 /// @see com::sun::star::beans::PropertyAttribute
 154 #define RT_ACCESS_MAYBEDEFAULT 0x0080
 155 /// @see com::sun::star::beans::PropertyAttribute
 156 #define RT_ACCESS_REMOVEABLE 0x0100
 157 /// @see com::sun::star::beans::PropertyAttribute
 158 #define RT_ACCESS_ATTRIBUTE 0x0200
 159 /// specifies that the field is a property
 160 #define RT_ACCESS_PROPERTY 0x0400
 161 /// specifies that the field is a constant or enum value
 162 #define RT_ACCESS_CONST 0x0800
 163 /// specifies that the property/attribute has read/write access
 164 #define RT_ACCESS_READWRITE 0x1000
 165 /// only to describe a union default label
 166 #define RT_ACCESS_DEFAULT 0x2000
 167
 168 /**
 169    Indicates that a member of a polymorphic struct type template is of a
 170    parameterized type.
 171
 172    Only valid for fields that represent members of polymorphic struct type
 173    templates.
 174
 175    @since UDK 3.2.0
 176  */
 177 #define RT_ACCESS_PARAMETERIZED_TYPE 0x4000
 178
 179 /**
 180    Flag for published individual constants.
 181
 182    Used in combination with RT_ACCESS_CONST for individual constants (which are
 183    not members of constant groups).
 184
 185    @since UDK 3.2.0
 186  */
 187 #define RT_ACCESS_PUBLISHED 0x8000
 188
 189 /** specifies the type of a field value.
 190
 191     A field can have a value if it repsresents a constant or an enum value.
 192  */
 193 enum RTValueType {
 194     RT_TYPE_NONE,
 195     RT_TYPE_BOOL,
 196     RT_TYPE_BYTE,
 197     RT_TYPE_INT16,
 198     RT_TYPE_UINT16,
 199     RT_TYPE_INT32,
 200     RT_TYPE_UINT32,
 201     RT_TYPE_INT64,
 202     RT_TYPE_UINT64,
 203     RT_TYPE_FLOAT,
 204     RT_TYPE_DOUBLE,
 205     RT_TYPE_STRING
 206 };
 207
 208 /** specifies a variable container for field values.
 209  */
 210 union RTConstValueUnion {
 211     sal_Bool aBool;
 212     sal_Int8 aByte;
 213     sal_Int16 aShort;
 214     sal_uInt16 aUShort;
 215     sal_Int32 aLong;
 216     sal_uInt32 aULong;
 217     sal_Int64 aHyper;
 218     sal_uInt64 aUHyper;
 219     float aFloat;
 220     double aDouble;
 221     sal_Unicode const * aString;
 222 };
 223
 224 /** specifies the mode of a method.
 225
 226     A method can be synchron or asynchron (oneway).  The const attribute for
 227     methods was removed so that the const values are deprecated.
 228  */
 229 enum RTMethodMode {
 230     /// indicates an invalid mode
 231     RT_MODE_INVALID,
 232
 233     /// indicates the asynchronous mode of a method
 234     RT_MODE_ONEWAY,
 235
 236     /// @deprecated
 237     RT_MODE_ONEWAY_CONST,
 238
 239     /// indicated the synchronous mode of a method
 240     RT_MODE_TWOWAY,
 241
 242     /// @deprecated
 243     RT_MODE_TWOWAY_CONST,
 244
 245     /**
 246        Indicates an extended attribute getter (that has a 'raises' clause) of an
 247        interface type.
 248
 249        @since UDK 3.2.0
 250      */
 251     RT_MODE_ATTRIBUTE_GET,
 252
 253     /**
 254        Indicates an extended attribute setter (that has a 'raises' clause) of an
 255        interface type.
 256
 257        @since UDK 3.2.0
 258      */
 259     RT_MODE_ATTRIBUTE_SET
 260 };
 261
 262 /** specifies the mode of a parameter.
 263
 264     There are three paramter modes which have impact of the handling of the
 265     paramter in the UNO bridges and the UNO code generation.
 266  */
 267 enum RTParamMode {
 268     /// indicates an invalid parameter mode
 269     RT_PARAM_INVALID = 0,
 270
 271     /// indicates a pure in parameter which is used by value
 272     RT_PARAM_IN = 1,
 273
 274     /// indicates a pure out parameter which is used by reference
 275     RT_PARAM_OUT = 2,
 276
 277     /// indicates a in and out parameter which is used also by reference
 278     RT_PARAM_INOUT = 3,
 279
 280     /**
 281        Indicates a rest parameter (currently only valid for service
 282        constructors).
 283
 284        This value can be combined with any of RT_PARAM_IN, RT_PARAM_OUT, and
 285        RT_PARAM_INOUT (however, service constructors currently only allow
 286        RT_PARAM_IN, anyway).
 287
 288        @since UDK 3.2.0
 289      */
 290     RT_PARAM_REST = 4
 291 };
 292
 293 /** specifies the type of a reference used in a service description.
 294  */
 295 enum RTReferenceType {
 296     /// the reference type is unknown
 297     RT_REF_INVALID,
 298
 299     /** the service support the interface that means a implementation of this
 300         service must implement this interface.
 301      */
 302     RT_REF_SUPPORTS,
 303
 304     /** @deprecated
 305         the service observes the interface.
 306      */
 307     RT_REF_OBSERVES,
 308
 309     /** the service exports the specified service that means this service
 310         provides also the specified service.
 311      */
 312     RT_REF_EXPORTS,
 313
 314     /** @deprecated
 315         the service needs the specified service that means in the context of
 316         this service the specified service will be used or must be available.
 317      */
 318     RT_REF_NEEDS,
 319
 320     /**
 321        Indicates a type parameter of a polymorphic struct type template.
 322
 323        @since UDK 3.2.0
 324      */
 325     RT_REF_TYPE_PARAMETER
 326 };
 327
 328 #ifdef __cplusplus
 329 }
 330 #endif
 331
 332 #endif
 333
 334 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */