1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 #ifndef _COM_SUN_STAR_UNO_ANY_H_ 24 #define _COM_SUN_STAR_UNO_ANY_H_ 25 26 #include <uno/any2.h> 27 #include <typelib/typedescription.h> 28 #include <com/sun/star/uno/Type.h> 29 #include "cppu/unotype.hxx" 30 #include <rtl/alloc.h> 31 32 33 namespace com 34 { 35 namespace sun 36 { 37 namespace star 38 { 39 namespace uno 40 { 41 42 /** C++ class representing an IDL any. 43 This class is used to transport any type defined in IDL. The class inherits from the 44 binary C representation of uno_Any. 45 You can insert a value by either using the <<= operators or the template function makeAny(). 46 No any can hold an any. You can extract values from an any by using the >>= operators which 47 return true if the any contains an assignable value (no data loss), e.g. the any contains a 48 short and you >>= it into a long variable. 49 */ 50 class Any : public uno_Any 51 { 52 public: 53 // these are here to force memory de/allocation to sal lib. 54 /** @internal */ 55 inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () ) 56 { return ::rtl_allocateMemory( nSize ); } 57 /** @internal */ 58 inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () ) 59 { ::rtl_freeMemory( pMem ); } 60 /** @internal */ 61 inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () ) 62 { return pMem; } 63 /** @internal */ 64 inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () ) 65 {} 66 67 /** Default constructor: Any holds no value; its type is void. 68 */ 69 inline Any() SAL_THROW( () ); 70 71 /** Templated ctor. Sets a copy of the given value. 72 73 @param value value of the Any 74 */ 75 template <typename T> 76 explicit inline Any( T const & value ); 77 /// Ctor support for C++ bool. 78 explicit inline Any( bool value ); 79 80 /** Copy constructor: Sets value of the given any. 81 82 @param rAny another any 83 */ 84 inline Any( const Any & rAny ) SAL_THROW( () ); 85 86 /** Constructor: Sets a copy of the given data. 87 88 @param pData_ value 89 @param rType type of value 90 */ 91 inline Any( const void * pData_, const Type & rType ) SAL_THROW( () ); 92 93 /** Constructor: Sets a copy of the given data. 94 95 @param pData_ value 96 @param pTypeDescr type of value 97 */ 98 inline Any( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () ); 99 100 /** Constructor: Sets a copy of the given data. 101 102 @param pData_ value 103 @param pType type of value 104 */ 105 inline Any( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW( () ); 106 107 /** Destructor: Destructs any content and frees memory. 108 */ 109 inline ~Any() SAL_THROW( () ); 110 111 /** Assignment operator: Sets the value of the given any. 112 113 @param rAny another any (right side) 114 @return this any 115 */ 116 inline Any & SAL_CALL operator = ( const Any & rAny ) SAL_THROW( () ); 117 118 /** Gets the type of the set value. 119 120 @return a Type object of the set value 121 */ 122 inline const Type & SAL_CALL getValueType() const SAL_THROW( () ) 123 { return * reinterpret_cast< const Type * >( &pType ); } 124 /** Gets the type of the set value. 125 126 @return the UNacquired type description reference of the set value 127 */ 128 inline typelib_TypeDescriptionReference * SAL_CALL getValueTypeRef() const SAL_THROW( () ) 129 { return pType; } 130 131 /** Gets the type description of the set value. Provides ownership of the type description! 132 Call an explicit typelib_typedescription_release() to release afterwards. 133 134 @param a pointer to type description pointer 135 */ 136 inline void SAL_CALL getValueTypeDescription( typelib_TypeDescription ** ppTypeDescr ) const SAL_THROW( () ) 137 { ::typelib_typedescriptionreference_getDescription( ppTypeDescr, pType ); } 138 139 /** Gets the type class of the set value. 140 141 @return the type class of the set value 142 */ 143 inline TypeClass SAL_CALL getValueTypeClass() const SAL_THROW( () ) 144 { return (TypeClass)pType->eTypeClass; } 145 146 /** Gets the type name of the set value. 147 148 @return the type name of the set value 149 */ 150 inline ::rtl::OUString SAL_CALL getValueTypeName() const SAL_THROW( () ); 151 152 /** Tests if any contains a value. 153 154 @return true if any has a value, false otherwise 155 */ 156 inline sal_Bool SAL_CALL hasValue() const SAL_THROW( () ) 157 { return (typelib_TypeClass_VOID != pType->eTypeClass); } 158 159 /** Gets a pointer to the set value. 160 161 @return a pointer to the set value 162 */ 163 inline const void * SAL_CALL getValue() const SAL_THROW( () ) 164 { return pData; } 165 166 #if ! defined(EXCEPTIONS_OFF) 167 /** Provides a value of specified type, so you can easily write e.g. 168 <pre> 169 sal_Int32 myVal = myAny.get<sal_Int32>(); 170 </pre> 171 Widening conversion without data loss is taken into account. 172 Throws a 173 <type scope="com::sun::star::uno">RuntimeException</type> 174 if the specified type cannot be provided. 175 176 @return value of specified type 177 @exception <type scope="com::sun::star::uno">RuntimeException</type> 178 in case the specified type cannot be provided 179 */ 180 template <typename T> 181 inline T get() const; 182 #endif // ! defined(EXCEPTIONS_OFF) 183 184 /** Sets a value. If the any already contains a value, that value will be destructed 185 and its memory freed. 186 187 @param pData_ pointer to value 188 @param rType type of value 189 */ 190 inline void SAL_CALL setValue( const void * pData_, const Type & rType ) SAL_THROW( () ); 191 /** Sets a value. If the any already contains a value, that value will be destructed 192 and its memory freed. 193 194 @param pData_ pointer to value 195 @param pType type of value 196 */ 197 inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW( () ); 198 /** Sets a value. If the any already contains a value, that value will be destructed 199 and its memory freed. 200 201 @param pData_ pointer to value 202 @param pTypeDescr type description of value 203 */ 204 inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () ); 205 206 /** Clears this any. If the any already contains a value, that value will be destructed 207 and its memory freed. After this has been called, the any does not contain a value. 208 */ 209 inline void SAL_CALL clear() SAL_THROW( () ); 210 211 /** Tests whether this any is extractable to a value of given type. 212 Widening conversion without data loss is taken into account. 213 214 @param rType destination type 215 @return true if this any is extractable to value of given type (e.g. using >>= operator) 216 */ 217 inline sal_Bool SAL_CALL isExtractableTo( const Type & rType ) const SAL_THROW( () ); 218 219 /** Tests whether this any can provide a value of specified type. 220 Widening conversion without data loss is taken into account. 221 222 @return true if this any can provide a value of specified type 223 (e.g. using >>= operator) 224 */ 225 template <typename T> 226 inline bool has() const; 227 228 /** Equality operator: compares two anys. 229 The values need not be of equal type, e.g. a short integer is compared to a long integer. 230 231 @param rAny another any (right side) 232 @return true if both any contains equal values 233 */ 234 inline sal_Bool SAL_CALL operator == ( const Any & rAny ) const SAL_THROW( () ); 235 /** Unequality operator: compares two anys. 236 The values need not be of equal type, e.g. a short integer is compared to a long integer. 237 238 @param rAny another any (right side) 239 @return true if both any contains unequal values 240 */ 241 inline sal_Bool SAL_CALL operator != ( const Any & rAny ) const SAL_THROW( () ); 242 243 private: 244 // not impl: forbid use with ambiguous type (sal_Unicode, sal_uInt16) 245 explicit Any( sal_uInt16 ); 246 #if defined(_MSC_VER) 247 // Omitting the following private declarations leads to an internal compiler 248 // error on MSVC (version 1310). 249 // not impl: forbid use with ambiguous type (sal_Unicode, sal_uInt16) 250 #if ! defined(EXCEPTIONS_OFF) 251 template <> 252 sal_uInt16 get<sal_uInt16>() const; 253 #endif // ! defined(EXCEPTIONS_OFF) 254 template <> 255 bool has<sal_uInt16>() const; 256 #endif // defined(_MSC_VER) 257 }; 258 259 /** Template function to generically construct an any from a C++ value. 260 261 @tplparam C value type 262 @param value a value 263 @return an any 264 */ 265 template< class C > 266 inline Any SAL_CALL makeAny( const C & value ) SAL_THROW( () ); 267 268 // additionally specialized for C++ bool 269 template<> 270 inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW( () ); 271 272 class BaseReference; 273 class Type; 274 275 /** Template binary <<= operator to set the value of an any. 276 277 @tplparam C value type 278 @param rAny destination any (left side) 279 @param value source value (right side) 280 */ 281 template< class C > 282 inline void SAL_CALL operator <<= ( Any & rAny, const C & value ) SAL_THROW( () ); 283 284 // additionally for C++ bool: 285 inline void SAL_CALL operator <<= ( Any & rAny, bool const & value ) 286 SAL_THROW( () ); 287 288 /** Template binary >>= operator to assign a value from an any. 289 If the any does not contain a value that can be assigned without data loss, then this 290 operation will fail returning false. 291 292 @tplparam C value type 293 @param rAny source any (left side) 294 @param value destination value (right side) 295 @return true if assignment was possible without data loss 296 */ 297 template< class C > 298 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW( () ); 299 300 /** Template equality operator: compares set value of left side any to right side value. 301 The values need not be of equal type, e.g. a short integer is compared to a long integer. 302 This operator can be implemented as template member function, if all supported compilers 303 can cope with template member functions. 304 305 @tplparam C value type 306 @param rAny another any (left side) 307 @param value a value (right side) 308 @return true if values are equal, false otherwise 309 */ 310 template< class C > 311 inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_THROW( () ); 312 /** Template unequality operator: compares set value of left side any to right side value. 313 The values need not be of equal type, e.g. a short integer is compared to a long integer. 314 This operator can be implemented as template member function, if all supported compilers 315 can cope with template member functions. 316 317 @tplparam C value type 318 @param rAny another any (left side) 319 @param value a value (right side) 320 @return true if values are unequal, false otherwise 321 */ 322 template< class C > 323 inline sal_Bool SAL_CALL operator != ( const Any & rAny, const C & value ) SAL_THROW( () ); 324 325 // additional specialized >>= and == operators 326 // bool 327 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Bool & value ) SAL_THROW( () ); 328 inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value ) SAL_THROW( () ); 329 template<> 330 inline sal_Bool SAL_CALL operator >>= ( Any const & rAny, bool & value ) 331 SAL_THROW( () ); 332 template<> 333 inline sal_Bool SAL_CALL operator == ( Any const & rAny, bool const & value ) 334 SAL_THROW( () ); 335 // byte 336 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int8 & value ) SAL_THROW( () ); 337 // short 338 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SAL_THROW( () ); 339 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) SAL_THROW( () ); 340 // long 341 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SAL_THROW( () ); 342 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) SAL_THROW( () ); 343 // hyper 344 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SAL_THROW( () ); 345 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) SAL_THROW( () ); 346 // float 347 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_THROW( () ); 348 // double 349 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_THROW( () ); 350 // string 351 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value ) SAL_THROW( () ); 352 inline sal_Bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value ) SAL_THROW( () ); 353 // type 354 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THROW( () ); 355 inline sal_Bool SAL_CALL operator == ( const Any & rAny, const Type & value ) SAL_THROW( () ); 356 // any 357 inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THROW( () ); 358 // interface 359 inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value ) SAL_THROW( () ); 360 361 } 362 } 363 } 364 } 365 366 /** Gets the meta type of IDL type any. 367 368 There are cases (involving templates) where uses of getCppuType are known to 369 not compile. Use cppu::UnoType or cppu::getTypeFavourUnsigned instead. 370 371 @param dummy typed pointer for function signature 372 @return type of IDL type any 373 */ 374 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::com::sun::star::uno::Any * ) SAL_THROW( () ) 375 { 376 return ::cppu::UnoType< ::com::sun::star::uno::Any >::get(); 377 } 378 379 #endif 380