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