chart2/source/inc/CommonFunctors.hxx

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