chart2/source/inc/CommonFunctors.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27 #ifndef CHART2_COMMONFUNCTORS_HXX
  28 #define CHART2_COMMONFUNCTORS_HXX
  29
  30 #include <algorithm>
  31 #include <functional>
  32 #include <rtl/math.hxx>
  33 #include <com/sun/star/uno/Any.hxx>
  34 #include <rtl/ustring.hxx>
  35 #include <com/sun/star/uno/Sequence.hxx>
  36 #include "charttoolsdllapi.hxx"
  37
  38 namespace chart
  39 {
  40 namespace CommonFunctors
  41 {
  42
  43 /** unary function to convert any type T into a ::com::sun::star::uno::Any.
  44
  45     <p>uno::makeAny is an inline function.  Thus is cannot be taken directly
  46     (via mem_fun_ptr)</p>
  47 */
  48 template< typename T >
  49     struct makeAny : public ::std::unary_function< T, ::com::sun::star::uno::Any >
  50 {
  51     ::com::sun::star::uno::Any operator() ( const T & aVal )
  52     {
  53         return ::com::sun::star::uno::makeAny( aVal );
  54     }
  55 };
  56
  57 /** unary function to convert ::com::sun::star::uno::Any into a double number.
  58
  59     <p>In case no number can be generated from the Any, NaN (see
  60     rtl::math::SetNAN()) is returned.</p>
  61 */
  62 struct OOO_DLLPUBLIC_CHARTTOOLS AnyToDouble : public ::std::unary_function< ::com::sun::star::uno::Any, double >
  63 {
  64     double operator() ( const ::com::sun::star::uno::Any & rAny )
  65     {
  66         double fResult;
  67         ::rtl::math::setNan( & fResult );
  68
  69         ::com::sun::star::uno::TypeClass eClass( rAny.getValueType().getTypeClass() );
  70         if( eClass == ::com::sun::star::uno::TypeClass_STRING )
  71         {
  72             rtl_math_ConversionStatus eConversionStatus;
  73             fResult = ::rtl::math::stringToDouble(
  74                 * reinterpret_cast< const ::rtl::OUString * >( rAny.getValue() ),
  75                 sal_Char( '.' ), sal_Char( ',' ),
  76                 & eConversionStatus, NULL );
  77
  78             if( eConversionStatus != rtl_math_ConversionStatus_Ok )
  79                 ::rtl::math::setNan( & fResult );
  80         }
  81         else if( eClass == ::com::sun::star::uno::TypeClass_DOUBLE )
  82         {
  83             fResult = * reinterpret_cast< const double * >( rAny.getValue() );
  84         }
  85
  86         return fResult;
  87     }
  88 };
  89
  90 /** unary function to convert ::com::sun::star::uno::Any into an
  91     ::rtl::OUString.
  92 */
  93 struct OOO_DLLPUBLIC_CHARTTOOLS AnyToString : public ::std::unary_function< ::com::sun::star::uno::Any,  ::rtl::OUString >
  94 {
  95     ::rtl::OUString operator() ( const ::com::sun::star::uno::Any & rAny )
  96     {
  97         ::com::sun::star::uno::TypeClass eClass( rAny.getValueType().getTypeClass() );
  98         if( eClass == ::com::sun::star::uno::TypeClass_DOUBLE )
  99         {
 100             const double* pDouble = reinterpret_cast< const double * >( rAny.getValue() );
 101             if( ::rtl::math::isNan(*pDouble) )
 102                 return ::rtl::OUString();
 103             return ::rtl::math::doubleToUString(
 104                 * pDouble,
 105                 rtl_math_StringFormat_Automatic,
 106                 -1, // use maximum decimal places available
 107                 sal_Char( '.' ), // decimal separator
 108                 false // do not erase trailing zeros
 109                 );
 110         }
 111         else if( eClass == ::com::sun::star::uno::TypeClass_STRING )
 112         {
 113             return * reinterpret_cast< const ::rtl::OUString * >( rAny.getValue() );
 114         }
 115
 116         return ::rtl::OUString();
 117     }
 118 };
 119
 120 /** unary function to convert an ::rtl::OUString into a double number.
 121
 122     <p>For conversion rtl::math::StringToDouble is used.</p>
 123  */
 124 struct OOO_DLLPUBLIC_CHARTTOOLS OUStringToDouble : public ::std::unary_function< ::rtl::OUString, double >
 125 {
 126     double operator() ( const ::rtl::OUString & rStr )
 127     {
 128         rtl_math_ConversionStatus eConversionStatus;
 129         double fResult = ::rtl::math::stringToDouble( rStr, '.', ',', & eConversionStatus, NULL );
 130
 131         if( eConversionStatus != rtl_math_ConversionStatus_Ok )
 132             ::rtl::math::setNan( & fResult );
 133
 134         return fResult;
 135     }
 136 };
 137
 138 /** unary function to convert a double number into an ::rtl::OUString.
 139
 140     <p>For conversion rtl::math::DoubleToOUString is used.</p>
 141  */
 142 struct OOO_DLLPUBLIC_CHARTTOOLS DoubleToOUString : public ::std::unary_function< double, ::rtl::OUString >
 143 {
 144     ::rtl::OUString operator() ( double fNumber )
 145     {
 146         return ::rtl::math::doubleToUString(
 147             fNumber,
 148             rtl_math_StringFormat_Automatic,
 149             -1, // use maximum number of decimal places
 150             static_cast< sal_Char >( '.' ),
 151             false // do not erase trailing zeros
 152             );
 153     }
 154 };
 155
 156 // ================================================================================
 157
 158 /** can be used to find an element with a specific first element in e.g. a
 159     vector of pairs (for searching keys in maps you will of course use map::find)
 160  */
 161 template< typename First, typename Second >
 162     class FirstOfPairEquals : public ::std::unary_function< ::std::pair< First, Second >, bool >
 163 {
 164 public:
 165     FirstOfPairEquals( const First & aVal )
 166             : m_aValueToCompareWith( aVal )
 167     {}
 168     bool operator() ( const ::std::pair< First, Second > & rElem )
 169     {
 170         return rElem.first == m_aValueToCompareWith;
 171     }
 172
 173 private:
 174     First m_aValueToCompareWith;
 175 };
 176
 177 /** can be used to find a certain value in a map
 178
 179     ::std::find_if( aMap.begin(), aMap.end(),
 180                     SecondOfPairEquals< string, int >( 42 ));
 181  */
 182 template< typename Key, typename Value >
 183     class SecondOfPairEquals : public ::std::unary_function< ::std::pair< Key, Value >, bool >
 184 {
 185 public:
 186     SecondOfPairEquals( const Value & aVal )
 187             : m_aValueToCompareWith( aVal )
 188     {}
 189     bool operator() ( const ::std::pair< Key, Value > & rMapElem )
 190     {
 191         return rMapElem.second == m_aValueToCompareWith;
 192     }
 193
 194 private:
 195     Value m_aValueToCompareWith;
 196 };
 197
 198 /** Searches for data in a given map, i.e. not for the key but for the data
 199     pointed to by the keys.
 200
 201     To find a key (value) you can use rMap.find( rValue )
 202  */
 203 template< class MapType >
 204     inline typename MapType::const_iterator
 205     findValueInMap( const MapType & rMap, const typename MapType::mapped_type & rData )
 206 {
 207     return ::std::find_if( rMap.begin(), rMap.end(),
 208                            ::std::compose1( ::std::bind2nd(
 209                                                 ::std::equal_to< typename MapType::mapped_type >(),
 210                                                 rData ),
 211                                             ::std::select2nd< typename MapType::value_type >()));
 212 }
 213
 214 /** Functor that deletes the object behind the given pointer by calling the
 215     delete operator
 216  */
 217 template< typename T >
 218     struct DeletePtr : public ::std::unary_function< T *, void >
 219 {
 220     void operator() ( T * pObj )
 221     { delete pObj; }
 222 };
 223
 224 } //  namespace CommonFunctors
 225 } //  namespace chart
 226
 227 // CHART2_COMMONFUNCTORS_HXX
 228 #endif