LCOV - code coverage report
Current view: top level - include/com/sun/star/uno - Any.h (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 6 18 33.3 %
Date: 2014-04-14 Functions: 3 9 33.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10