include/cppu/unotype.hxx

   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 /*
  21  * This file is part of LibreOffice published API.
  22  */
  23
  24 #ifndef INCLUDED_CPPU_UNOTYPE_HXX
  25 #define INCLUDED_CPPU_UNOTYPE_HXX
  26
  27 #include "sal/config.h"
  28
  29 #include <cstddef>
  30
  31 #if defined LIBO_INTERNAL_ONLY
  32 #include <type_traits>
  33 #endif
  34
  35 #include "sal/types.h"
  36 #include "typelib/typeclass.h"
  37 #include "typelib/typedescription.h"
  38
  39 namespace com { namespace sun { namespace star { namespace uno {
  40     class Type;
  41     class Any;
  42     class Exception;
  43     template< typename > class Reference;
  44     template< typename > class Sequence;
  45     class XInterface;
  46 } } } }
  47 namespace rtl { class OUString; }
  48
  49 namespace cppu {
  50
  51 template< typename > class UnoType;
  52
  53 /**
  54    A unique C++ type representing the UNO type VOID in cppu::UnoType.
  55
  56    This type is declared but not defined.  Its only use is as a template
  57    argument to cppu::UnoType.
  58
  59    @since UDK 3.2.2
  60 */
  61 struct UnoVoidType;
  62
  63 /**
  64    A unique C++ type representing the UNO type UNSIGNED SHORT in cppu::UnoType.
  65
  66    The UNO types UNSIGNED SHORT and CHAR map to the same C++ type, so this C++
  67    type is needed to unambiguously specify UNO types in cppu::UnoType.
  68
  69    This type is declared but not defined.  Its only use is as a template
  70    argument to cppu::UnoType.
  71
  72    @since UDK 3.2.2
  73 */
  74 struct UnoUnsignedShortType;
  75
  76 /**
  77    A unique C++ type representing the UNO type CHAR in cppu::UnoType.
  78
  79    The UNO types UNSIGNED SHORT and CHAR map to the same C++ type, so this C++
  80    type is needed to unambiguously specify UNO types in cppu::UnoType.
  81
  82    This type is declared but not defined.  Its only use is as a template
  83    argument to cppu::UnoType.
  84
  85    @since UDK 3.2.2
  86 */
  87 struct UnoCharType;
  88
  89 /**
  90    A unique C++ type template representing the UNO sequence types in
  91    cppu::UnoType.
  92
  93    The UNO types UNSIGNED SHORT and CHAR map to the same C++ type, so this C++
  94    type is needed to unambiguously specify UNO types in cppu::UnoType.
  95
  96    This type is declared but not defined.  Its only use is as a template
  97    argument to cppu::UnoType.
  98
  99    @since UDK 3.2.2
 100 */
 101 template< typename > struct UnoSequenceType;
 102
 103 namespace detail {
 104
 105 inline css::uno::Type const & getTypeFromTypeDescriptionReference(
 106     ::typelib_TypeDescriptionReference * const * tdr)
 107 {
 108     return *reinterpret_cast< css::uno::Type const * >(tdr);
 109 }
 110
 111 inline css::uno::Type const &
 112 getTypeFromTypeClass(::typelib_TypeClass tc) {
 113     return getTypeFromTypeDescriptionReference(
 114         ::typelib_static_type_getByTypeClass(tc));
 115 }
 116
 117 }
 118
 119 }
 120
 121 namespace cppu { namespace detail {
 122
 123 inline css::uno::Type const &
 124 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::cppu::UnoVoidType const *) {
 125     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_VOID);
 126 }
 127
 128 inline css::uno::Type const &
 129 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER bool const *) {
 130     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_BOOLEAN);
 131 }
 132
 133 inline css::uno::Type const &
 134 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER sal_Bool const *) {
 135     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_BOOLEAN);
 136 }
 137
 138 inline css::uno::Type const &
 139 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::sal_Int8 const *) {
 140     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_BYTE);
 141 }
 142
 143 inline css::uno::Type const &
 144 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::sal_Int16 const *) {
 145     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_SHORT);
 146 }
 147
 148 inline css::uno::Type const &
 149 cppu_detail_getUnoType(
 150     SAL_UNUSED_PARAMETER ::cppu::UnoUnsignedShortType const *)
 151 {
 152     return ::cppu::detail::getTypeFromTypeClass(
 153         ::typelib_TypeClass_UNSIGNED_SHORT);
 154 }
 155
 156 #if defined LIBO_INTERNAL_ONLY
 157     // cf. sal/types.h sal_Unicode
 158 inline css::uno::Type const &
 159 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER sal_uInt16 const *) {
 160     return cppu::detail::getTypeFromTypeClass(typelib_TypeClass_UNSIGNED_SHORT);
 161 }
 162 #endif
 163
 164 inline css::uno::Type const &
 165 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::sal_Int32 const *) {
 166     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_LONG);
 167 }
 168
 169 inline css::uno::Type const &
 170 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::sal_uInt32 const *) {
 171     return ::cppu::detail::getTypeFromTypeClass(
 172         ::typelib_TypeClass_UNSIGNED_LONG);
 173 }
 174
 175 inline css::uno::Type const &
 176 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::sal_Int64 const *) {
 177     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_HYPER);
 178 }
 179
 180 inline css::uno::Type const &
 181 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::sal_uInt64 const *) {
 182     return ::cppu::detail::getTypeFromTypeClass(
 183         ::typelib_TypeClass_UNSIGNED_HYPER);
 184 }
 185
 186 inline css::uno::Type const &
 187 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER float const *) {
 188     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_FLOAT);
 189 }
 190
 191 inline css::uno::Type const &
 192 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER double const *) {
 193     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_DOUBLE);
 194 }
 195
 196 inline css::uno::Type const &
 197 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::cppu::UnoCharType const *) {
 198     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_CHAR);
 199 }
 200
 201 #if defined LIBO_INTERNAL_ONLY
 202     // cf. sal/types.h sal_Unicode
 203 inline css::uno::Type const &
 204 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER sal_Unicode const *) {
 205     return cppu::detail::getTypeFromTypeClass(typelib_TypeClass_CHAR);
 206 }
 207 #endif
 208
 209 inline css::uno::Type const &
 210 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER ::rtl::OUString const *) {
 211     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_STRING);
 212 }
 213
 214 inline css::uno::Type const &
 215 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER css::uno::Type const *)
 216 {
 217     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_TYPE);
 218 }
 219
 220 inline css::uno::Type const &
 221 cppu_detail_getUnoType(SAL_UNUSED_PARAMETER css::uno::Any const *)
 222 {
 223     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_ANY);
 224 }
 225
 226 template< typename T > inline css::uno::Type const &
 227 cppu_detail_getUnoType(
 228     SAL_UNUSED_PARAMETER ::cppu::UnoSequenceType< T > const *)
 229 {
 230     //TODO: depending on memory model, the following might not work reliably
 231     static typelib_TypeDescriptionReference * p = NULL;
 232     if (p == NULL) {
 233         ::typelib_static_sequence_type_init(
 234             &p, ::cppu::UnoType< T >::get().getTypeLibType());
 235     }
 236     return ::cppu::detail::getTypeFromTypeDescriptionReference(&p);
 237 }
 238
 239 template< typename T > inline css::uno::Type const &
 240 cppu_detail_getUnoType(
 241     SAL_UNUSED_PARAMETER css::uno::Sequence< T > const *)
 242 {
 243     return cppu_detail_getUnoType(
 244         static_cast< ::cppu::UnoSequenceType< T > * >(NULL));
 245 }
 246
 247 inline css::uno::Type const & cppu_detail_getUnoType(
 248     SAL_UNUSED_PARAMETER css::uno::Exception const *)
 249 {
 250     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_EXCEPTION);
 251 }
 252
 253 inline css::uno::Type const & cppu_detail_getUnoType(
 254     SAL_UNUSED_PARAMETER css::uno::XInterface const *)
 255 {
 256     return ::cppu::detail::getTypeFromTypeClass(::typelib_TypeClass_INTERFACE);
 257 }
 258
 259 template< typename T > inline css::uno::Type const &
 260 cppu_detail_getUnoType(
 261     SAL_UNUSED_PARAMETER css::uno::Reference< T > const *)
 262 {
 263     return ::cppu::UnoType< T >::get();
 264 }
 265
 266 } }
 267
 268 namespace cppu {
 269
 270 /**
 271    Get the css::uno::Type instance representing a certain UNO type.
 272
 273    For each C++ type representing a UNO type, the corresponding instantiation of
 274    this template has a public static member function get().  (The template is
 275    specialized for C++ templates representing polymorphic struct type templates
 276    of UNO.  In those cases, it does not work to instantiate UnoType with a C++
 277    type that is derived from a C++ type that represents a UNO type, but does not
 278    itself represent a UNO type.  In all other cases, UnoType even works for such
 279    C++ types that are unambiguously derived from one C++ type that represents a
 280    UNO type.)  In addition to those C++ types that are mappings of UNO types
 281    (except for sal_uInt16 and sal_Unicode, see below), the following C++ types
 282    are appropriate as template arguments: void, cppu::UnoVoidType, bool,
 283    cppu::UnoUnsignedShortType, cppu::UnoCharType, cppu::UnoSequenceType with any
 284    appropriate template argument (the latter three to unambiguously specify UNO
 285    types, as the UNO types UNSIGNED SHORT and CHAR map to the same C++ type),
 286    and css::uno::Reference with any appropriate template argument.
 287
 288    @since UDK 3.2.2
 289 */
 290 template< typename T > class UnoType {
 291 public:
 292     static css::uno::Type const & get() {
 293         using namespace ::cppu::detail;
 294 #if defined LIBO_INTERNAL_ONLY
 295         typedef typename std::remove_reference<T>::type T1;
 296             // for certain uses of UnoType<decltype(x)>
 297 #else
 298         typedef T T1;
 299 #endif
 300         return cppu_detail_getUnoType(static_cast< T1 * >(NULL));
 301     }
 302
 303 private:
 304     UnoType(UnoType &) SAL_DELETED_FUNCTION;
 305     ~UnoType() SAL_DELETED_FUNCTION;
 306     void operator =(UnoType &) SAL_DELETED_FUNCTION;
 307 };
 308
 309 template<> css::uno::Type inline const & UnoType<void>::get() {
 310     return cppu::UnoType<cppu::UnoVoidType>::get();
 311 }
 312
 313 /**
 314    A working replacement for getCppuType (see there).
 315
 316    There are three overloads of this function that together form the replacement
 317    of getCppuType.  The replacement has exactly the same semantics as
 318    getCppuType, in that it returns correct results for the UNO type UNSIGNED
 319    SHORT but not for the UNO type CHAR.
 320
 321    @since UDK 3.2.2
 322 */
 323 template< typename T > inline css::uno::Type const &
 324 getTypeFavourUnsigned(SAL_UNUSED_PARAMETER T const *) {
 325     return ::cppu::UnoType< T >::get();
 326 }
 327
 328 /**
 329    A working replacement for getCppuType (see there).
 330
 331    There are three overloads of this function that together form the replacement
 332    of getCppuType.  The replacement has exactly the same semantics as
 333    getCppuType, in that it returns correct results for the UNO type UNSIGNED
 334    SHORT but not for the UNO type CHAR.
 335
 336    @since UDK 3.2.2
 337 */
 338 inline css::uno::Type const &
 339 getTypeFavourUnsigned(SAL_UNUSED_PARAMETER ::sal_uInt16 const *) {
 340     return ::cppu::UnoType< ::cppu::UnoUnsignedShortType >::get();
 341 }
 342
 343 /**
 344    A working replacement for getCppuType (see there).
 345
 346    There are three overloads of this function that together form the replacement
 347    of getCppuType.  The replacement has exactly the same semantics as
 348    getCppuType, in that it returns correct results for the UNO type UNSIGNED
 349    SHORT but not for the UNO type CHAR.
 350
 351    @since UDK 3.2.2
 352 */
 353 template< typename T > inline css::uno::Type const &
 354 getTypeFavourUnsigned(css::uno::Sequence< T > const *);
 355     // defined in com/sun/star/uno/Sequence.hxx
 356
 357 /// @cond INTERNAL
 358
 359 /**
 360    A working replacement for getCppuType (see there).
 361
 362    There are three overloads of this function that together form the replacement
 363    of the getCppuType template.  The replacement has exactly the same semantics
 364    as the getCppuType template, in that it returns correct results for the UNO
 365    type CHAR but not for the UNO type UNSIGNED SHORT.  Additionally, it also
 366    returns the intended results for sequence types.
 367
 368    @since UDK 3.2.3
 369 */
 370 template< typename T > inline css::uno::Type const &
 371 getTypeFavourChar(SAL_UNUSED_PARAMETER T const *) {
 372     return ::cppu::UnoType< T >::get();
 373 }
 374
 375 /**
 376    A working replacement for getCppuType (see there).
 377
 378    There are three overloads of this function that together form the replacement
 379    of the getCppuType template.  The replacement has exactly the same semantics
 380    as the getCppuType template, in that it returns correct results for the UNO
 381    type CHAR but not for the UNO type UNSIGNED SHORT.  Additionally, it also
 382    returns the intended results for sequence types.
 383
 384    @since UDK 3.2.3
 385 */
 386 inline css::uno::Type const &
 387 getTypeFavourChar(SAL_UNUSED_PARAMETER ::sal_Unicode const *) {
 388     return ::cppu::UnoType< ::cppu::UnoCharType >::get();
 389 }
 390
 391 /**
 392    A working replacement for getCppuType (see there).
 393
 394    There are three overloads of this function that together form the replacement
 395    of the getCppuType template.  The replacement has exactly the same semantics
 396    as the getCppuType template, in that it returns correct results for the UNO
 397    type CHAR but not for the UNO type UNSIGNED SHORT.  Additionally, it also
 398    returns the intended results for sequence types.
 399
 400    @since UDK 3.2.3
 401 */
 402 template< typename T > inline css::uno::Type const &
 403 getTypeFavourChar(css::uno::Sequence< T > const *);
 404     // defined in com/sun/star/uno/Sequence.hxx
 405
 406 /// @endcond
 407
 408 }
 409
 410 #endif
 411
 412 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */