LibreOffice
LibreOffice 5.2 SDK C/C++ API Reference
Any.hxx
Go to the documentation of this file.
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 <cstddef>
26 #include <iomanip>
27 #include <ostream>
28 
29 #include <com/sun/star/uno/Any.h>
30 #include <uno/data.h>
31 #include <uno/sequence2.h>
35 #include <com/sun/star/uno/RuntimeException.hpp>
36 #include <cppu/cppudllapi.h>
37 #include <cppu/unotype.hxx>
38 
39 extern "C" CPPU_DLLPUBLIC rtl_uString * SAL_CALL cppu_Any_extraction_failure_msg(
40  uno_Any const * pAny, typelib_TypeDescriptionReference * pType )
42 
43 namespace com
44 {
45 namespace sun
46 {
47 namespace star
48 {
49 namespace uno
50 {
51 
52 
53 inline Any::Any()
54 {
55  ::uno_any_construct( this, NULL, NULL, cpp_acquire );
56 }
57 
58 
59 template <typename T>
60 inline Any::Any( T const & value )
61 {
63  this, const_cast<T *>(&value),
64  ::cppu::getTypeFavourUnsigned(&value).getTypeLibType(),
65  cpp_acquire );
66 }
67 
68 inline Any::Any( bool value )
69 {
70  sal_Bool b = value;
72  this, &b, cppu::UnoType<bool>::get().getTypeLibType(),
73  cpp_acquire );
74 }
75 
76 #if defined LIBO_INTERNAL_ONLY
77 template<typename T1, typename T2>
78 Any::Any(rtl::OUStringConcat<T1, T2> const & value): Any(rtl::OUString(value))
79 {}
80 #endif
81 
82 inline Any::Any( const Any & rAny )
83 {
84  ::uno_type_any_construct( this, rAny.pData, rAny.pType, cpp_acquire );
85 }
86 
87 inline Any::Any( const void * pData_, const Type & rType )
88 {
90  this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
91  cpp_acquire );
92 }
93 
94 inline Any::Any( const void * pData_, typelib_TypeDescription * pTypeDescr )
95 {
97  this, const_cast< void * >( pData_ ), pTypeDescr, cpp_acquire );
98 }
99 
100 inline Any::Any( const void * pData_, typelib_TypeDescriptionReference * pType_ )
101 {
103  this, const_cast< void * >( pData_ ), pType_, cpp_acquire );
104 }
105 
106 inline Any::~Any()
107 {
109  this, cpp_release );
110 }
111 
112 inline Any & Any::operator = ( const Any & rAny )
113 {
114  if (this != &rAny)
115  {
117  this, rAny.pData, rAny.pType,
119  }
120  return *this;
121 }
122 
123 inline ::rtl::OUString Any::getValueTypeName() const
124 {
125  return ::rtl::OUString( pType->pTypeName );
126 }
127 
128 inline void Any::setValue( const void * pData_, const Type & rType )
129 {
131  this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
133 }
134 
135 inline void Any::setValue( const void * pData_, typelib_TypeDescriptionReference * pType_ )
136 {
138  this, const_cast< void * >( pData_ ), pType_,
140 }
141 
142 inline void Any::setValue( const void * pData_, typelib_TypeDescription * pTypeDescr )
143 {
145  this, const_cast< void * >( pData_ ), pTypeDescr,
147 }
148 
149 inline void Any::clear()
150 {
152  this, cpp_release );
153 }
154 
155 inline bool Any::isExtractableTo( const Type & rType ) const
156 {
158  rType.getTypeLibType(), pData, pType,
160 }
161 
162 
163 template <typename T>
164 inline bool Any::has() const
165 {
166  Type const & rType = ::cppu::getTypeFavourUnsigned(static_cast< T * >(0));
168  rType.getTypeLibType(), pData, pType,
170  cpp_release );
171 }
172 
173 inline bool Any::operator == ( const Any & rAny ) const
174 {
176  pData, pType, rAny.pData, rAny.pType,
178 }
179 
180 inline bool Any::operator != ( const Any & rAny ) const
181 {
182  return (! ::uno_type_equalData(
183  pData, pType, rAny.pData, rAny.pType,
185 }
186 
187 
188 template< class C >
189 inline Any SAL_CALL makeAny( const C & value )
190 {
191  return Any(value);
192 }
193 
194 #if !defined LIBO_INTERNAL_ONLY
195 template<> Any makeAny(sal_uInt16 const & value)
197 #endif
198 
199 template<typename T> Any toAny(T const & value) { return makeAny(value); }
200 
201 template<> Any toAny(Any const & value) { return value; }
202 
203 template< class C >
204 inline void SAL_CALL operator <<= ( Any & rAny, const C & value )
205 {
206  const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
208  &rAny, const_cast< C * >( &value ), rType.getTypeLibType(),
210 }
211 
212 // additionally for C++ bool:
213 
214 template<>
215 inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
216 {
217  sal_Bool b = value;
219  &rAny, &b, cppu::UnoType<bool>::get().getTypeLibType(),
221 }
222 
223 
224 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
225 template< class C1, class C2 >
226 inline void SAL_CALL operator <<= ( Any & rAny, const rtl::OUStringConcat< C1, C2 >& value )
227 {
228  const rtl::OUString str( value );
229  const Type & rType = ::cppu::getTypeFavourUnsigned(&str);
231  &rAny, const_cast< rtl::OUString * >( &str ), rType.getTypeLibType(),
233 }
234 #endif
235 
236 template< class C >
237 inline bool SAL_CALL operator >>= ( const Any & rAny, C & value )
238 {
239  const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
241  &value, rType.getTypeLibType(),
242  rAny.pData, rAny.pType,
245 }
246 
247 // bool
248 
249 template<>
250 inline bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Bool & value )
251 {
252  if (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass)
253  {
254  value = bool(* static_cast< const sal_Bool * >( rAny.pData ));
255  return true;
256  }
257  return false;
258 }
259 
260 template<>
261 inline bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value )
262 {
263  return (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass &&
264  bool(value) == bool(* static_cast< const sal_Bool * >( rAny.pData )));
265 }
266 
267 
268 template<>
269 inline bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
270 {
271  if (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN)
272  {
273  value = *static_cast< sal_Bool const * >( rAny.pData );
274  return true;
275  }
276  return false;
277 }
278 
279 
280 template<>
281 inline bool SAL_CALL operator == ( Any const & rAny, bool const & value )
282 {
283  return (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN &&
284  (value ==
285  bool(*static_cast< sal_Bool const * >( rAny.pData ))));
286 }
287 
288 // byte
289 
290 template<>
291 inline bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Int8 & value )
292 {
293  if (typelib_TypeClass_BYTE == rAny.pType->eTypeClass)
294  {
295  value = * static_cast< const sal_Int8 * >( rAny.pData );
296  return true;
297  }
298  return false;
299 }
300 // short
301 
302 template<>
303 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value )
304 {
305  switch (rAny.pType->eTypeClass)
306  {
308  value = * static_cast< const sal_Int8 * >( rAny.pData );
309  return true;
312  value = * static_cast< const sal_Int16 * >( rAny.pData );
313  return true;
314  default:
315  return false;
316  }
317 }
318 
319 template<>
320 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value )
321 {
322  switch (rAny.pType->eTypeClass)
323  {
325  value = (sal_uInt16)( * static_cast< const sal_Int8 * >( rAny.pData ) );
326  return true;
329  value = * static_cast< const sal_uInt16 * >( rAny.pData );
330  return true;
331  default:
332  return false;
333  }
334 }
335 // long
336 
337 template<>
338 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value )
339 {
340  switch (rAny.pType->eTypeClass)
341  {
343  value = * static_cast< const sal_Int8 * >( rAny.pData );
344  return true;
346  value = * static_cast< const sal_Int16 * >( rAny.pData );
347  return true;
349  value = * static_cast< const sal_uInt16 * >( rAny.pData );
350  return true;
353  value = * static_cast< const sal_Int32 * >( rAny.pData );
354  return true;
355  default:
356  return false;
357  }
358 }
359 
360 template<>
361 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value )
362 {
363  switch (rAny.pType->eTypeClass)
364  {
366  value = (sal_uInt32)( * static_cast< const sal_Int8 * >( rAny.pData ) );
367  return true;
369  value = (sal_uInt32)( * static_cast< const sal_Int16 * >( rAny.pData ) );
370  return true;
372  value = * static_cast< const sal_uInt16 * >( rAny.pData );
373  return true;
376  value = * static_cast< const sal_uInt32 * >( rAny.pData );
377  return true;
378  default:
379  return false;
380  }
381 }
382 // hyper
383 
384 template<>
385 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value )
386 {
387  switch (rAny.pType->eTypeClass)
388  {
390  value = * static_cast< const sal_Int8 * >( rAny.pData );
391  return true;
393  value = * static_cast< const sal_Int16 * >( rAny.pData );
394  return true;
396  value = * static_cast< const sal_uInt16 * >( rAny.pData );
397  return true;
399  value = * static_cast< const sal_Int32 * >( rAny.pData );
400  return true;
402  value = * static_cast< const sal_uInt32 * >( rAny.pData );
403  return true;
406  value = * static_cast< const sal_Int64 * >( rAny.pData );
407  return true;
408  default:
409  return false;
410  }
411 }
412 
413 template<>
414 inline bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value )
415 {
416  switch (rAny.pType->eTypeClass)
417  {
419  value = (sal_uInt64)( * static_cast< const sal_Int8 * >( rAny.pData ) );
420  return true;
422  value = (sal_uInt64)( * static_cast< const sal_Int16 * >( rAny.pData ) );
423  return true;
425  value = * static_cast< const sal_uInt16 * >( rAny.pData );
426  return true;
428  value = (sal_uInt64)( * static_cast< const sal_Int32 * >( rAny.pData ) );
429  return true;
431  value = * static_cast< const sal_uInt32 * >( rAny.pData );
432  return true;
435  value = * static_cast< const sal_uInt64 * >( rAny.pData );
436  return true;
437  default:
438  return false;
439  }
440 }
441 // float
442 
443 template<>
444 inline bool SAL_CALL operator >>= ( const Any & rAny, float & value )
445 {
446  switch (rAny.pType->eTypeClass)
447  {
449  value = * static_cast< const sal_Int8 * >( rAny.pData );
450  return true;
452  value = * static_cast< const sal_Int16 * >( rAny.pData );
453  return true;
455  value = * static_cast< const sal_uInt16 * >( rAny.pData );
456  return true;
458  value = * static_cast< const float * >( rAny.pData );
459  return true;
460  default:
461  return false;
462  }
463 }
464 // double
465 
466 template<>
467 inline bool SAL_CALL operator >>= ( const Any & rAny, double & value )
468 {
469  switch (rAny.pType->eTypeClass)
470  {
472  value = * static_cast< const sal_Int8 * >( rAny.pData );
473  return true;
475  value = * static_cast< const sal_Int16 * >( rAny.pData );
476  return true;
478  value = * static_cast< const sal_uInt16 * >( rAny.pData );
479  return true;
481  value = * static_cast< const sal_Int32 * >( rAny.pData );
482  return true;
484  value = * static_cast< const sal_uInt32 * >( rAny.pData );
485  return true;
487  value = * static_cast< const float * >( rAny.pData );
488  return true;
490  value = * static_cast< const double * >( rAny.pData );
491  return true;
492  default:
493  return false;
494  }
495 }
496 // string
497 
498 template<>
499 inline bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value )
500 {
501  if (typelib_TypeClass_STRING == rAny.pType->eTypeClass)
502  {
503  value = * static_cast< const ::rtl::OUString * >( rAny.pData );
504  return true;
505  }
506  return false;
507 }
508 
509 template<>
510 inline bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value )
511 {
512  return (typelib_TypeClass_STRING == rAny.pType->eTypeClass &&
513  value.equals( * static_cast< const ::rtl::OUString * >( rAny.pData ) ));
514 }
515 // type
516 
517 template<>
518 inline bool SAL_CALL operator >>= ( const Any & rAny, Type & value )
519 {
520  if (typelib_TypeClass_TYPE == rAny.pType->eTypeClass)
521  {
522  value = * static_cast< const Type * >( rAny.pData );
523  return true;
524  }
525  return false;
526 }
527 
528 template<>
529 inline bool SAL_CALL operator == ( const Any & rAny, const Type & value )
530 {
531  return (typelib_TypeClass_TYPE == rAny.pType->eTypeClass &&
532  value.equals( * static_cast< const Type * >( rAny.pData ) ));
533 }
534 // any
535 
536 template<>
537 inline bool SAL_CALL operator >>= ( const Any & rAny, Any & value )
538 {
539  if (&rAny != &value)
540  {
542  &value, rAny.pData, rAny.pType,
544  }
545  return true;
546 }
547 // interface
548 
549 template<>
550 inline bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value )
551 {
552  if (typelib_TypeClass_INTERFACE == rAny.pType->eTypeClass)
553  {
554  return static_cast< const BaseReference * >( rAny.pData )->operator == ( value );
555  }
556  return false;
557 }
558 
559 // operator to compare to an any.
560 
561 template< class C >
562 inline bool SAL_CALL operator == ( const Any & rAny, const C & value )
563 {
564  const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
566  rAny.pData, rAny.pType,
567  const_cast< C * >( &value ), rType.getTypeLibType(),
569 }
570 // operator to compare to an any. may use specialized operators ==.
571 
572 template< class C >
573 inline bool SAL_CALL operator != ( const Any & rAny, const C & value )
574 {
575  return (! operator == ( rAny, value ));
576 }
577 
578 template <typename T>
579 T Any::get() const
580 {
581  T value = T();
582  if (! (*this >>= value)) {
583  throw RuntimeException(
584  ::rtl::OUString(
586  this,
587  ::cppu::getTypeFavourUnsigned(&value).getTypeLibType() ),
588  SAL_NO_ACQUIRE ) );
589  }
590  return value;
591 }
592 
599 template<typename charT, typename traits>
600 inline std::basic_ostream<charT, traits> &operator<<(std::basic_ostream<charT, traits> &o, Any const &any) {
601  o << "<Any: (" << any.getValueTypeName() << ')';
602  switch(any.pType->eTypeClass) {
604  break;
606  o << ' ' << any.get<bool>();
607  break;
612  o << ' ' << any.get<sal_Int64>();
613  break;
617  o << ' ' << any.get<sal_uInt64>();
618  break;
621  o << ' ' << any.get<double>();
622  break;
623  case typelib_TypeClass_CHAR: {
624  std::ios_base::fmtflags flgs = o.setf(
625  std::ios_base::hex, std::ios_base::basefield);
626  charT fill = o.fill('0');
627  o << " U+" << std::setw(4)
628  << *static_cast<sal_Unicode const *>(any.getValue());
629  o.setf(flgs);
630  o.fill(fill);
631  break;
632  }
634  o << ' ' << any.get<rtl::OUString>();
635  break;
637  o << ' ' << any.get<css::uno::Type>().getTypeName();
638  break;
640  o << " len "
641  << ((*static_cast<uno_Sequence * const *>(any.getValue()))->
642  nElements);
643  break;
645  o << ' ' << *static_cast<sal_Int32 const *>(any.getValue());
646  break;
649  o << ' ' << any.getValue();
650  break;
652  o << ' ' << *static_cast<void * const *>(any.getValue());
653  break;
654  default:
655  assert(false); // this cannot happen
656  break;
657  }
658  o << '>';
659  return o;
660 }
661 
662 }
663 }
664 }
665 }
666 
667 #endif
668 
669 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
#define CPPU_DLLPUBLIC
Definition: cppudllapi.h:10
#define SAL_THROW_EXTERN_C()
Nothrow specification for C functions.
Definition: types.h:370
type class of interface
Definition: typeclass.h:79
type class of type
Definition: typeclass.h:55
void cpp_acquire(void *pCppI)
Function to acquire a C++ interface.
Definition: genfunc.hxx:41
inline ::rtl::OUString getValueTypeName() const
Gets the type name of the set value.
Definition: Any.hxx:123
void operator<<=(Any &rAny, const C &value)
Template binary <<= operator to set the value of an any.
Definition: Any.hxx:204
CPPU_DLLPUBLIC void uno_any_destruct(uno_Any *pValue, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Destructs an any.
CPPU_DLLPUBLIC void uno_any_construct(uno_Any *pDest, void *pSource, struct _typelib_TypeDescription *pTypeDescr, uno_AcquireFunc acquire) SAL_THROW_EXTERN_C()
Constructs an any with a given value.
void setValue(const void *pData_, const Type &rType)
Sets a value.
Definition: Any.hxx:128
type class of struct
Definition: typeclass.h:63
CPPU_DLLPUBLIC sal_Bool uno_type_assignData(void *pDest, struct _typelib_TypeDescriptionReference *pDestType, void *pSource, struct _typelib_TypeDescriptionReference *pSourceType, uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Assigns a destination value with a source value.
signed char sal_Int8
Definition: types.h:53
bool operator==(const Any &rAny) const
Equality operator: compares two anys.
Definition: Any.hxx:173
css::uno::Type const & getTypeFavourUnsigned(SAL_UNUSED_PARAMETER T const *)
A working replacement for getCppuType (see there).
Definition: unotype.hxx:320
Definition: types.h:391
T get() const
Provides a value of specified type, so you can easily write e.g.
Definition: Any.hxx:579
struct SAL_DLLPUBLIC_RTTI _typelib_TypeDescriptionReference typelib_TypeDescriptionReference
Holds a weak reference to a type description.
void clear()
Clears this any.
Definition: Any.hxx:149
type class of unsigned short
Definition: typeclass.h:39
CPPU_DLLPUBLIC rtl_uString * cppu_Any_extraction_failure_msg(uno_Any const *pAny, typelib_TypeDescriptionReference *pType) SAL_THROW_EXTERN_C()
type class of byte
Definition: typeclass.h:35
Any makeAny(const C &value)
Template function to generically construct an any from a C++ value.
Definition: Any.hxx:189
CPPU_DLLPUBLIC void uno_type_any_construct(uno_Any *pDest, void *pSource, struct _typelib_TypeDescriptionReference *pType, uno_AcquireFunc acquire) SAL_THROW_EXTERN_C()
Constructs an any with a given value.
type class of unsigned hyper
Definition: typeclass.h:47
sal_uInt16 sal_Unicode
Definition: types.h:155
struct SAL_DLLPUBLIC_RTTI _typelib_TypeDescription typelib_TypeDescription
Full type description of a type.
unsigned char sal_Bool
Definition: types.h:48
struct SAL_DLLPUBLIC_RTTI _uno_Any uno_Any
This is the binary specification of an UNO any.
type class of void
Definition: typeclass.h:29
~Any()
Destructor: Destructs any content and frees memory.
Definition: Any.hxx:106
bool isExtractableTo(const Type &rType) const
Tests whether this any is extractable to a value of given type.
Definition: Any.hxx:155
type class of double
Definition: typeclass.h:51
CPPU_DLLPUBLIC void uno_type_any_assign(uno_Any *pDest, void *pSource, struct _typelib_TypeDescriptionReference *pType, uno_AcquireFunc acquire, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Assign an any with a given value.
type class of string
Definition: typeclass.h:53
type class of char
Definition: typeclass.h:31
void cpp_release(void *pCppI)
Function to release a C++ interface.
Definition: genfunc.hxx:46
type class of enum
Definition: typeclass.h:59
Get the css::uno::Type instance representing a certain UNO type.
Definition: unotype.hxx:47
Any toAny(T const &value)
Wrap a value in an Any, if necessary.
Definition: Any.hxx:199
definition of a no acquire enum for ctors
Definition: types.h:388
This base class serves as a base class for all template reference classes and has been introduced due...
Definition: Reference.h:58
type class of long
Definition: typeclass.h:41
type class of exception
Definition: typeclass.h:70
This String class provides base functionality for C++ like Unicode character array handling...
Definition: ustring.hxx:106
CPPU_DLLPUBLIC void uno_any_assign(uno_Any *pDest, void *pSource, struct _typelib_TypeDescription *pTypeDescr, uno_AcquireFunc acquire, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Assign an any with a given value.
bool equals(const Type &rType) const
Compares two types.
Definition: Type.h:173
bool operator>>=(const Any &rAny, C &value)
Template binary >>= operator to assign a value from an any.
Definition: Any.hxx:237
Any & operator=(const Any &rAny)
Assignment operator: Sets the value of the given any.
Definition: Any.hxx:112
This is the binary specification of a SAL sequence.
Definition: types.h:345
type class of unsigned long
Definition: typeclass.h:43
Any()
Default constructor: Any holds no value; its type is void.
Definition: Any.hxx:53
type class of short
Definition: typeclass.h:37
rtl::OUString getTypeName(rtl::OUString const &rEnvDcp)
Get the OBI type part of an environment descriptor.
Definition: EnvDcp.hxx:38
bool operator!=(const Any &rAny) const
Unequality operator: compares two anys.
Definition: Any.hxx:180
CPPU_DLLPUBLIC sal_Bool uno_type_isAssignableFromData(struct _typelib_TypeDescriptionReference *pAssignable, void *pFrom, struct _typelib_TypeDescriptionReference *pFromType, uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Tests whether a value of given type is assignable from given value.
type class of float
Definition: typeclass.h:49
bool has() const
Tests whether this any can provide a value of specified type.
Definition: Any.hxx:164
CPPU_DLLPUBLIC sal_Bool uno_type_equalData(void *pVal1, struct _typelib_TypeDescriptionReference *pVal1Type, void *pVal2, struct _typelib_TypeDescriptionReference *pVal2Type, uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Tests if two values are equal.
CPPU_DLLPUBLIC void uno_any_clear(uno_Any *pValue, uno_ReleaseFunc release) SAL_THROW_EXTERN_C()
Sets value to void.
void * cpp_queryInterface(void *pCppI, typelib_TypeDescriptionReference *pType)
Function to query for a C++ interface.
Definition: genfunc.hxx:51
typelib_TypeDescriptionReference * getTypeLibType() const
Gets the C typelib type description reference pointer.
Definition: Type.h:154
type class of hyper
Definition: typeclass.h:45
type class of boolean
Definition: typeclass.h:33
type class of sequence
Definition: typeclass.h:72
C++ class representing an IDL meta type.
Definition: Type.h:54
Any(bool value)
Ctor support for C++ bool.
Definition: Any.hxx:68
C++ class representing an IDL any.
Definition: Any.h:52