include/com/sun/star/uno/Any.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 #ifndef INCLUDED_COM_SUN_STAR_UNO_ANY_HXX
  20 #define INCLUDED_COM_SUN_STAR_UNO_ANY_HXX
  21
  22 #include "sal/config.h"
  23
  24 #include <algorithm>
  25 #include <cassert>
  26 #include <cstddef>
  27 #include <iomanip>
  28 #include <ostream>
  29 #include <utility>
  30
  31 #include "com/sun/star/uno/Any.h"
  32 #include "uno/data.h"
  33 #include "uno/sequence2.h"
  34 #include "com/sun/star/uno/Type.hxx"
  35 #include "com/sun/star/uno/Reference.h"
  36 #include "com/sun/star/uno/genfunc.hxx"
  37 #include "com/sun/star/uno/RuntimeException.hpp"
  38 #include "cppu/cppudllapi.h"
  39 #include "cppu/unotype.hxx"
  40
  41 extern "C" CPPU_DLLPUBLIC rtl_uString * SAL_CALL cppu_Any_extraction_failure_msg(
  42     uno_Any const * pAny, typelib_TypeDescriptionReference * pType )
  43     SAL_THROW_EXTERN_C();
  44
  45 namespace com
  46 {
  47 namespace sun
  48 {
  49 namespace star
  50 {
  51 namespace uno
  52 {
  53
  54
  55 inline Any::Any()
  56 {
  57     ::uno_any_construct( this, NULL, NULL, cpp_acquire );
  58 }
  59
  60
  61 template <typename T>
  62 inline Any::Any( T const & value )
  63 {
  64     ::uno_type_any_construct(
  65         this, const_cast<T *>(&value),
  66         ::cppu::getTypeFavourUnsigned(&value).getTypeLibType(),
  67         cpp_acquire );
  68 }
  69
  70 inline Any::Any( bool value )
  71 {
  72     sal_Bool b = value;
  73     ::uno_type_any_construct(
  74         this, &b, cppu::UnoType<bool>::get().getTypeLibType(),
  75         cpp_acquire );
  76 }
  77
  78 #if defined LIBO_INTERNAL_ONLY
  79 template<typename T1, typename T2>
  80 Any::Any(rtl::OUStringConcat<T1, T2> && value):
  81     Any(rtl::OUString(std::move(value)))
  82 {}
  83 #endif
  84
  85 inline Any::Any( const Any & rAny )
  86 {
  87     ::uno_type_any_construct( this, rAny.pData, rAny.pType, cpp_acquire );
  88 }
  89
  90 inline Any::Any( const void * pData_, const Type & rType )
  91 {
  92     ::uno_type_any_construct(
  93         this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
  94         cpp_acquire );
  95 }
  96
  97 inline Any::Any( const void * pData_, typelib_TypeDescription * pTypeDescr )
  98 {
  99     ::uno_any_construct(
 100         this, const_cast< void * >( pData_ ), pTypeDescr, cpp_acquire );
 101 }
 102
 103 inline Any::Any( const void * pData_, typelib_TypeDescriptionReference * pType_ )
 104 {
 105     ::uno_type_any_construct(
 106         this, const_cast< void * >( pData_ ), pType_, cpp_acquire );
 107 }
 108
 109 inline Any::~Any()
 110 {
 111     ::uno_any_destruct(
 112         this, cpp_release );
 113 }
 114
 115 inline Any & Any::operator = ( const Any & rAny )
 116 {
 117     if (this != &rAny)
 118     {
 119         ::uno_type_any_assign(
 120             this, rAny.pData, rAny.pType,
 121             cpp_acquire, cpp_release );
 122     }
 123     return *this;
 124 }
 125
 126 #if defined LIBO_INTERNAL_ONLY
 127
 128 namespace detail {
 129
 130 inline void moveAnyInternals(Any & from, Any & to) noexcept {
 131     uno_any_construct(&to, nullptr, nullptr, &cpp_acquire);
 132     std::swap(from.pType, to.pType);
 133     std::swap(from.pData, to.pData);
 134     std::swap(from.pReserved, to.pReserved);
 135     if (to.pData == &from.pReserved) {
 136         to.pData = &to.pReserved;
 137     }
 138     // This leaves from.pData (where "from" is now VOID) dangling to somewhere (cf.
 139     // CONSTRUCT_EMPTY_ANY, cppu/source/uno/prim.hxx), but what's relevant is
 140     // only that it isn't a nullptr (as e.g. >>= -> uno_type_assignData ->
 141     // _assignData takes a null pSource to mean "construct a default value").
 142 }
 143
 144 }
 145
 146 Any::Any(Any && other) noexcept {
 147     detail::moveAnyInternals(other, *this);
 148 }
 149
 150 Any & Any::operator =(Any && other) noexcept {
 151     uno_any_destruct(this, &cpp_release);
 152     detail::moveAnyInternals(other, *this);
 153     return *this;
 154 }
 155
 156 #endif
 157
 158 inline ::rtl::OUString Any::getValueTypeName() const
 159 {
 160     return ::rtl::OUString( pType->pTypeName );
 161 }
 162
 163 inline void Any::setValue( const void * pData_, const Type & rType )
 164 {
 165     ::uno_type_any_assign(
 166         this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
 167         cpp_acquire, cpp_release );
 168 }
 169
 170 inline void Any::setValue( const void * pData_, typelib_TypeDescriptionReference * pType_ )
 171 {
 172     ::uno_type_any_assign(
 173         this, const_cast< void * >( pData_ ), pType_,
 174         cpp_acquire, cpp_release );
 175 }
 176
 177 inline void Any::setValue( const void * pData_, typelib_TypeDescription * pTypeDescr )
 178 {
 179     ::uno_any_assign(
 180         this, const_cast< void * >( pData_ ), pTypeDescr,
 181         cpp_acquire, cpp_release );
 182 }
 183
 184 inline void Any::clear()
 185 {
 186     ::uno_any_clear(
 187         this, cpp_release );
 188 }
 189
 190 inline bool Any::isExtractableTo( const Type & rType ) const
 191 {
 192     return ::uno_type_isAssignableFromData(
 193         rType.getTypeLibType(), pData, pType,
 194         cpp_queryInterface, cpp_release );
 195 }
 196
 197
 198 template <typename T>
 199 inline bool Any::has() const
 200 {
 201     Type const & rType = ::cppu::getTypeFavourUnsigned(static_cast< T * >(0));
 202     return ::uno_type_isAssignableFromData(
 203         rType.getTypeLibType(), pData, pType,
 204         cpp_queryInterface,
 205         cpp_release );
 206 }
 207
 208 #if defined LIBO_INTERNAL_ONLY
 209 template<> bool Any::has<Any>() const = delete;
 210 #endif
 211
 212 inline bool Any::operator == ( const Any & rAny ) const
 213 {
 214     return ::uno_type_equalData(
 215         pData, pType, rAny.pData, rAny.pType,
 216         cpp_queryInterface, cpp_release );
 217 }
 218
 219 inline bool Any::operator != ( const Any & rAny ) const
 220 {
 221     return (! ::uno_type_equalData(
 222         pData, pType, rAny.pData, rAny.pType,
 223         cpp_queryInterface, cpp_release ));
 224 }
 225
 226
 227 template< class C >
 228 inline Any SAL_CALL makeAny( const C & value )
 229 {
 230     return Any(value);
 231 }
 232
 233 #if !defined LIBO_INTERNAL_ONLY
 234 template<> Any makeAny(sal_uInt16 const & value)
 235 { return Any(&value, cppu::UnoType<cppu::UnoUnsignedShortType>::get()); }
 236 #endif
 237
 238 template<typename T> Any toAny(T const & value) { return makeAny(value); }
 239
 240 template<> Any toAny(Any const & value) { return value; }
 241
 242 #if defined LIBO_INTERNAL_ONLY
 243
 244 template<typename T1, typename T2>
 245 Any makeAny(rtl::OUStringConcat<T1, T2> && value)
 246 { return Any(std::move(value)); }
 247
 248 template<typename T1, typename T2>
 249 Any toAny(rtl::OUStringConcat<T1, T2> && value)
 250 { return makeAny(std::move(value)); }
 251
 252 template<typename T>
 253 Any makeAny(rtl::OUStringNumber<T> && value)
 254 { return Any(OUString(std::move(value))); }
 255
 256 template<typename T>
 257 Any toAny(rtl::OUStringNumber<T> && value)
 258 { return makeAny(std::move(value)); }
 259
 260 template<typename T> bool fromAny(Any const & any, T * value) {
 261     assert(value != nullptr);
 262     return any >>= *value;
 263 }
 264
 265 template<> bool fromAny(Any const & any, Any * value) {
 266     assert(value != nullptr);
 267     *value = any;
 268     return true;
 269 }
 270
 271 #endif
 272
 273 template< class C >
 274 inline void SAL_CALL operator <<= ( Any & rAny, const C & value )
 275 {
 276     const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
 277     ::uno_type_any_assign(
 278         &rAny, const_cast< C * >( &value ), rType.getTypeLibType(),
 279         cpp_acquire, cpp_release );
 280 }
 281
 282 // additionally for C++ bool:
 283
 284 template<>
 285 inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
 286 {
 287     sal_Bool b = value;
 288     ::uno_type_any_assign(
 289         &rAny, &b, cppu::UnoType<bool>::get().getTypeLibType(),
 290         cpp_acquire, cpp_release );
 291 }
 292
 293
 294 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
 295 template< class C1, class C2 >
 296 inline void SAL_CALL operator <<= ( Any & rAny, rtl::OUStringConcat< C1, C2 >&& value )
 297 {
 298     const rtl::OUString str( std::move(value) );
 299     const Type & rType = ::cppu::getTypeFavourUnsigned(&str);
 300     ::uno_type_any_assign(
 301         &rAny, const_cast< rtl::OUString * >( &str ), rType.getTypeLibType(),
 302         cpp_acquire, cpp_release );
 303 }
 304 template<typename T1, typename T2>
 305 void operator <<=(Any &, rtl::OUStringConcat<T1, T2> const &) = delete;
 306 template< class C >
 307 inline void SAL_CALL operator <<= ( Any & rAny, rtl::OUStringNumber< C >&& value )
 308 {
 309     const rtl::OUString str( std::move(value) );
 310     const Type & rType = ::cppu::getTypeFavourUnsigned(&str);
 311     ::uno_type_any_assign(
 312         &rAny, const_cast< rtl::OUString * >( &str ), rType.getTypeLibType(),
 313         cpp_acquire, cpp_release );
 314 }
 315 template<typename T>
 316 void operator <<=(Any &, rtl::OUStringNumber<T> const &) = delete;
 317 #endif
 318
 319 #if defined LIBO_INTERNAL_ONLY
 320 template<> void SAL_CALL operator <<=(Any &, Any const &) = delete;
 321 #endif
 322
 323 template< class C >
 324 inline bool SAL_CALL operator >>= ( const Any & rAny, C & value )
 325 {
 326     const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
 327     return ::uno_type_assignData(
 328         &value, rType.getTypeLibType(),
 329         rAny.pData, rAny.pType,
 330         cpp_queryInterface,
 331         cpp_acquire, cpp_release );
 332 }
 333
 334 // bool
 335
 336 template<>
 337 inline bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Bool & value )
 338 {
 339     if (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass)
 340     {
 341         value = bool(* static_cast< const sal_Bool * >( rAny.pData ));
 342         return true;
 343     }
 344     return false;
 345 }
 346
 347 template<>
 348 inline bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value )
 349 {
 350     return (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass &&
 351             bool(value) == bool(* static_cast< const sal_Bool * >( rAny.pData )));
 352 }
 353
 354
 355 template<>
 356 inline bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
 357 {
 358     if (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN)
 359     {
 360         value = *static_cast< sal_Bool const * >( rAny.pData );
 361         return true;
 362     }
 363     return false;
 364 }
 365
 366
 367 template<>
 368 inline bool SAL_CALL operator == ( Any const & rAny, bool const & value )
 369 {
 370     return (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN &&
 371             (value ==
 372              bool(*static_cast< sal_Bool const * >( rAny.pData ))));
 373 }
 374
 375 // byte
 376
 377 template<>
 378 inline bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Int8 & value )
 379 {
 380     if (typelib_TypeClass_BYTE == rAny.pType->eTypeClass)
 381     {
 382         value = * static_cast< const sal_Int8 * >( rAny.pData );
 383         return true;
 384     }
 385     return false;
 386 }
 387 // short
 388
 389 template<>
 390 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value )
 391 {
 392     switch (rAny.pType->eTypeClass)
 393     {
 394     case typelib_TypeClass_BYTE:
 395         value = * static_cast< const sal_Int8 * >( rAny.pData );
 396         return true;
 397     case typelib_TypeClass_SHORT:
 398     case typelib_TypeClass_UNSIGNED_SHORT:
 399         value = * static_cast< const sal_Int16 * >( rAny.pData );
 400         return true;
 401     default:
 402         return false;
 403     }
 404 }
 405
 406 template<>
 407 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value )
 408 {
 409     switch (rAny.pType->eTypeClass)
 410     {
 411     case typelib_TypeClass_BYTE:
 412         value = static_cast<sal_uInt16>( * static_cast< const sal_Int8 * >( rAny.pData ) );
 413         return true;
 414     case typelib_TypeClass_SHORT:
 415     case typelib_TypeClass_UNSIGNED_SHORT:
 416         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 417         return true;
 418     default:
 419         return false;
 420     }
 421 }
 422 // long
 423
 424 template<>
 425 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value )
 426 {
 427     switch (rAny.pType->eTypeClass)
 428     {
 429     case typelib_TypeClass_BYTE:
 430         value = * static_cast< const sal_Int8 * >( rAny.pData );
 431         return true;
 432     case typelib_TypeClass_SHORT:
 433         value = * static_cast< const sal_Int16 * >( rAny.pData );
 434         return true;
 435     case typelib_TypeClass_UNSIGNED_SHORT:
 436         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 437         return true;
 438     case typelib_TypeClass_LONG:
 439     case typelib_TypeClass_UNSIGNED_LONG:
 440         value = * static_cast< const sal_Int32 * >( rAny.pData );
 441         return true;
 442     default:
 443         return false;
 444     }
 445 }
 446
 447 template<>
 448 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value )
 449 {
 450     switch (rAny.pType->eTypeClass)
 451     {
 452     case typelib_TypeClass_BYTE:
 453         value = static_cast<sal_uInt32>( * static_cast< const sal_Int8 * >( rAny.pData ) );
 454         return true;
 455     case typelib_TypeClass_SHORT:
 456         value = static_cast<sal_uInt32>( * static_cast< const sal_Int16 * >( rAny.pData ) );
 457         return true;
 458     case typelib_TypeClass_UNSIGNED_SHORT:
 459         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 460         return true;
 461     case typelib_TypeClass_LONG:
 462     case typelib_TypeClass_UNSIGNED_LONG:
 463         value = * static_cast< const sal_uInt32 * >( rAny.pData );
 464         return true;
 465     default:
 466         return false;
 467     }
 468 }
 469 // hyper
 470
 471 template<>
 472 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value )
 473 {
 474     switch (rAny.pType->eTypeClass)
 475     {
 476     case typelib_TypeClass_BYTE:
 477         value = * static_cast< const sal_Int8 * >( rAny.pData );
 478         return true;
 479     case typelib_TypeClass_SHORT:
 480         value = * static_cast< const sal_Int16 * >( rAny.pData );
 481         return true;
 482     case typelib_TypeClass_UNSIGNED_SHORT:
 483         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 484         return true;
 485     case typelib_TypeClass_LONG:
 486         value = * static_cast< const sal_Int32 * >( rAny.pData );
 487         return true;
 488     case typelib_TypeClass_UNSIGNED_LONG:
 489         value = * static_cast< const sal_uInt32 * >( rAny.pData );
 490         return true;
 491     case typelib_TypeClass_HYPER:
 492     case typelib_TypeClass_UNSIGNED_HYPER:
 493         value = * static_cast< const sal_Int64 * >( rAny.pData );
 494         return true;
 495     default:
 496         return false;
 497     }
 498 }
 499
 500 template<>
 501 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value )
 502 {
 503     switch (rAny.pType->eTypeClass)
 504     {
 505     case typelib_TypeClass_BYTE:
 506         value = static_cast<sal_uInt64>( * static_cast< const sal_Int8 * >( rAny.pData ) );
 507         return true;
 508     case typelib_TypeClass_SHORT:
 509         value = static_cast<sal_uInt64>( * static_cast< const sal_Int16 * >( rAny.pData ) );
 510         return true;
 511     case typelib_TypeClass_UNSIGNED_SHORT:
 512         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 513         return true;
 514     case typelib_TypeClass_LONG:
 515         value = static_cast<sal_uInt64>( * static_cast< const sal_Int32 * >( rAny.pData ) );
 516         return true;
 517     case typelib_TypeClass_UNSIGNED_LONG:
 518         value = * static_cast< const sal_uInt32 * >( rAny.pData );
 519         return true;
 520     case typelib_TypeClass_HYPER:
 521     case typelib_TypeClass_UNSIGNED_HYPER:
 522         value = * static_cast< const sal_uInt64 * >( rAny.pData );
 523         return true;
 524     default:
 525         return false;
 526     }
 527 }
 528 // float
 529
 530 template<>
 531 inline bool SAL_CALL operator >>= ( const Any & rAny, float & value )
 532 {
 533     switch (rAny.pType->eTypeClass)
 534     {
 535     case typelib_TypeClass_BYTE:
 536         value = * static_cast< const sal_Int8 * >( rAny.pData );
 537         return true;
 538     case typelib_TypeClass_SHORT:
 539         value = * static_cast< const sal_Int16 * >( rAny.pData );
 540         return true;
 541     case typelib_TypeClass_UNSIGNED_SHORT:
 542         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 543         return true;
 544     case typelib_TypeClass_FLOAT:
 545         value = * static_cast< const float * >( rAny.pData );
 546         return true;
 547     default:
 548         return false;
 549     }
 550 }
 551 // double
 552
 553 template<>
 554 inline bool SAL_CALL operator >>= ( const Any & rAny, double & value )
 555 {
 556     switch (rAny.pType->eTypeClass)
 557     {
 558     case typelib_TypeClass_BYTE:
 559         value = * static_cast< const sal_Int8 * >( rAny.pData );
 560         return true;
 561     case typelib_TypeClass_SHORT:
 562         value = * static_cast< const sal_Int16 * >( rAny.pData );
 563         return true;
 564     case typelib_TypeClass_UNSIGNED_SHORT:
 565         value = * static_cast< const sal_uInt16 * >( rAny.pData );
 566         return true;
 567     case typelib_TypeClass_LONG:
 568         value = * static_cast< const sal_Int32 * >( rAny.pData );
 569         return true;
 570     case typelib_TypeClass_UNSIGNED_LONG:
 571         value = * static_cast< const sal_uInt32 * >( rAny.pData );
 572         return true;
 573     case typelib_TypeClass_FLOAT:
 574         value = * static_cast< const float * >( rAny.pData );
 575         return true;
 576     case typelib_TypeClass_DOUBLE:
 577         value = * static_cast< const double * >( rAny.pData );
 578         return true;
 579     default:
 580         return false;
 581     }
 582 }
 583 // string
 584
 585 template<>
 586 inline bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value )
 587 {
 588     if (typelib_TypeClass_STRING == rAny.pType->eTypeClass)
 589     {
 590         value = * static_cast< const ::rtl::OUString * >( rAny.pData );
 591         return true;
 592     }
 593     return false;
 594 }
 595
 596 template<>
 597 inline bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value )
 598 {
 599     return (typelib_TypeClass_STRING == rAny.pType->eTypeClass &&
 600             value == * static_cast< const ::rtl::OUString * >( rAny.pData ) );
 601 }
 602 // type
 603
 604 template<>
 605 inline bool SAL_CALL operator >>= ( const Any & rAny, Type & value )
 606 {
 607     if (typelib_TypeClass_TYPE == rAny.pType->eTypeClass)
 608     {
 609         value = * static_cast< const Type * >( rAny.pData );
 610         return true;
 611     }
 612     return false;
 613 }
 614
 615 template<>
 616 inline bool SAL_CALL operator == ( const Any & rAny, const Type & value )
 617 {
 618     return (typelib_TypeClass_TYPE == rAny.pType->eTypeClass &&
 619             value.equals( * static_cast< const Type * >( rAny.pData ) ));
 620 }
 621 // any
 622
 623 #if defined LIBO_INTERNAL_ONLY
 624 template<> bool SAL_CALL operator >>=(Any const &, Any &) = delete;
 625 #else
 626 template<>
 627 inline bool SAL_CALL operator >>= ( const Any & rAny, Any & value )
 628 {
 629     if (&rAny != &value)
 630     {
 631         ::uno_type_any_assign(
 632             &value, rAny.pData, rAny.pType,
 633             cpp_acquire, cpp_release );
 634     }
 635     return true;
 636 }
 637 #endif
 638 // interface
 639
 640 template<>
 641 inline bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value )
 642 {
 643     if (typelib_TypeClass_INTERFACE == rAny.pType->eTypeClass)
 644     {
 645         return static_cast< const BaseReference * >( rAny.pData )->operator == ( value );
 646     }
 647     return false;
 648 }
 649
 650 // operator to compare to an any.
 651
 652 template< class C >
 653 inline bool SAL_CALL operator == ( const Any & rAny, const C & value )
 654 {
 655     const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
 656     return ::uno_type_equalData(
 657         rAny.pData, rAny.pType,
 658         const_cast< C * >( &value ), rType.getTypeLibType(),
 659         cpp_queryInterface, cpp_release );
 660 }
 661 // operator to compare to an any.  may use specialized operators ==.
 662
 663 template< class C >
 664 inline bool SAL_CALL operator != ( const Any & rAny, const C & value )
 665 {
 666     return (! operator == ( rAny, value ));
 667 }
 668
 669 template <typename T>
 670 T Any::get() const
 671 {
 672     T value = T();
 673     if (! (*this >>= value)) {
 674         throw RuntimeException(
 675             ::rtl::OUString(
 676                 cppu_Any_extraction_failure_msg(
 677                     this,
 678                     ::cppu::getTypeFavourUnsigned(&value).getTypeLibType() ),
 679                 SAL_NO_ACQUIRE ) );
 680     }
 681     return value;
 682 }
 683
 684 #if defined LIBO_INTERNAL_ONLY
 685 template<> Any Any::get() const = delete;
 686 #endif
 687
 688 /**
 689    Support for Any in std::ostream (and thus in CPPUNIT_ASSERT or SAL_INFO
 690    macros, for example).
 691
 692    @since LibreOffice 4.2
 693 */
 694 template<typename charT, typename traits>
 695 inline std::basic_ostream<charT, traits> &operator<<(std::basic_ostream<charT, traits> &o, Any const &any) {
 696     o << "<Any: (" << any.getValueTypeName() << ')';
 697     switch(any.pType->eTypeClass) {
 698         case typelib_TypeClass_VOID:
 699             break;
 700         case typelib_TypeClass_BOOLEAN:
 701             o << ' ' << any.get<bool>();
 702             break;
 703         case typelib_TypeClass_BYTE:
 704         case typelib_TypeClass_SHORT:
 705         case typelib_TypeClass_LONG:
 706         case typelib_TypeClass_HYPER:
 707             o << ' ' << any.get<sal_Int64>();
 708             break;
 709         case typelib_TypeClass_UNSIGNED_SHORT:
 710         case typelib_TypeClass_UNSIGNED_LONG:
 711         case typelib_TypeClass_UNSIGNED_HYPER:
 712             o << ' ' << any.get<sal_uInt64>();
 713             break;
 714         case typelib_TypeClass_FLOAT:
 715         case typelib_TypeClass_DOUBLE:
 716             o << ' ' << any.get<double>();
 717             break;
 718         case typelib_TypeClass_CHAR: {
 719             std::ios_base::fmtflags flgs = o.setf(
 720                 std::ios_base::hex, std::ios_base::basefield);
 721             charT fill = o.fill('0');
 722             o << " U+" << std::setw(4)
 723               << unsigned(*static_cast<sal_Unicode const *>(any.getValue()));
 724             o.setf(flgs);
 725             o.fill(fill);
 726             break;
 727         }
 728         case typelib_TypeClass_STRING:
 729             o << ' ' << any.get<rtl::OUString>();
 730             break;
 731         case typelib_TypeClass_TYPE:
 732             o << ' ' << any.get<css::uno::Type>().getTypeName();
 733             break;
 734         case typelib_TypeClass_SEQUENCE:
 735             o << " len "
 736               << ((*static_cast<uno_Sequence * const *>(any.getValue()))->
 737                   nElements);
 738             break;
 739         case typelib_TypeClass_ENUM:
 740             o << ' ' << *static_cast<sal_Int32 const *>(any.getValue());
 741             break;
 742         case typelib_TypeClass_STRUCT:
 743         case typelib_TypeClass_EXCEPTION:
 744             o << ' ' << any.getValue();
 745             break;
 746         case typelib_TypeClass_INTERFACE:
 747             o << ' ' << *static_cast<void * const *>(any.getValue());
 748             break;
 749         default:
 750             assert(false); // this cannot happen
 751             break;
 752     }
 753     o << '>';
 754     return o;
 755 }
 756
 757 }
 758 }
 759 }
 760 }
 761
 762 #endif
 763
 764 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */