| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| #ifndef CHART2_COMMONFUNCTORS_HXX |
| #define CHART2_COMMONFUNCTORS_HXX |
| |
| #include <algorithm> |
| #include <functional> |
| #include <rtl/math.hxx> |
| #include <com/sun/star/uno/Any.hxx> |
| #include <rtl/ustring.hxx> |
| #include <com/sun/star/uno/Sequence.hxx> |
| #include "charttoolsdllapi.hxx" |
| |
| namespace chart |
| { |
| namespace CommonFunctors |
| { |
| |
| /** unary function to convert any type T into a ::com::sun::star::uno::Any. |
| |
| <p>uno::makeAny is an inline function. Thus is cannot be taken directly |
| (via mem_fun_ptr)</p> |
| */ |
| template< typename T > |
| struct makeAny : public ::std::unary_function< T, ::com::sun::star::uno::Any > |
| { |
| ::com::sun::star::uno::Any operator() ( const T & aVal ) |
| { |
| return ::com::sun::star::uno::makeAny( aVal ); |
| } |
| }; |
| |
| /** unary function to convert ::com::sun::star::uno::Any into a double number. |
| |
| <p>In case no number can be generated from the Any, NaN (see |
| rtl::math::SetNAN()) is returned.</p> |
| */ |
| struct OOO_DLLPUBLIC_CHARTTOOLS AnyToDouble : public ::std::unary_function< ::com::sun::star::uno::Any, double > |
| { |
| double operator() ( const ::com::sun::star::uno::Any & rAny ) |
| { |
| double fResult; |
| ::rtl::math::setNan( & fResult ); |
| |
| ::com::sun::star::uno::TypeClass eClass( rAny.getValueType().getTypeClass() ); |
| if( eClass == ::com::sun::star::uno::TypeClass_DOUBLE ) |
| { |
| fResult = * reinterpret_cast< const double * >( rAny.getValue() ); |
| } |
| |
| return fResult; |
| } |
| }; |
| |
| /** unary function to convert ::com::sun::star::uno::Any into an |
| ::rtl::OUString. |
| */ |
| struct OOO_DLLPUBLIC_CHARTTOOLS AnyToString : public ::std::unary_function< ::com::sun::star::uno::Any, ::rtl::OUString > |
| { |
| ::rtl::OUString operator() ( const ::com::sun::star::uno::Any & rAny ) |
| { |
| ::com::sun::star::uno::TypeClass eClass( rAny.getValueType().getTypeClass() ); |
| if( eClass == ::com::sun::star::uno::TypeClass_DOUBLE ) |
| { |
| const double* pDouble = reinterpret_cast< const double * >( rAny.getValue() ); |
| if( ::rtl::math::isNan(*pDouble) ) |
| return ::rtl::OUString(); |
| return ::rtl::math::doubleToUString( |
| * pDouble, |
| rtl_math_StringFormat_Automatic, |
| -1, // use maximum decimal places available |
| sal_Char( '.' ), // decimal separator |
| false // do not erase trailing zeros |
| ); |
| } |
| else if( eClass == ::com::sun::star::uno::TypeClass_STRING ) |
| { |
| return * reinterpret_cast< const ::rtl::OUString * >( rAny.getValue() ); |
| } |
| |
| return ::rtl::OUString(); |
| } |
| }; |
| |
| /** unary function to convert an ::rtl::OUString into a double number. |
| |
| <p>For conversion rtl::math::StringToDouble is used.</p> |
| */ |
| struct OOO_DLLPUBLIC_CHARTTOOLS OUStringToDouble : public ::std::unary_function< ::rtl::OUString, double > |
| { |
| double operator() ( const ::rtl::OUString & rStr ) |
| { |
| rtl_math_ConversionStatus eConversionStatus; |
| double fResult = ::rtl::math::stringToDouble( rStr, '.', ',', & eConversionStatus, NULL ); |
| |
| if( eConversionStatus != rtl_math_ConversionStatus_Ok ) |
| ::rtl::math::setNan( & fResult ); |
| |
| return fResult; |
| } |
| }; |
| |
| /** unary function to convert a double number into an ::rtl::OUString. |
| |
| <p>For conversion rtl::math::DoubleToOUString is used.</p> |
| */ |
| struct OOO_DLLPUBLIC_CHARTTOOLS DoubleToOUString : public ::std::unary_function< double, ::rtl::OUString > |
| { |
| ::rtl::OUString operator() ( double fNumber ) |
| { |
| return ::rtl::math::doubleToUString( |
| fNumber, |
| rtl_math_StringFormat_Automatic, |
| -1, // use maximum number of decimal places |
| static_cast< sal_Char >( '.' ), |
| false // do not erase trailing zeros |
| ); |
| } |
| }; |
| |
| // ================================================================================ |
| |
| /** can be used to find an element with a specific first element in e.g. a |
| vector of pairs (for searching keys in maps you will of course use map::find) |
| */ |
| template< typename First, typename Second > |
| class FirstOfPairEquals : public ::std::unary_function< ::std::pair< First, Second >, bool > |
| { |
| public: |
| FirstOfPairEquals( const First & aVal ) |
| : m_aValueToCompareWith( aVal ) |
| {} |
| bool operator() ( const ::std::pair< First, Second > & rElem ) |
| { |
| return rElem.first == m_aValueToCompareWith; |
| } |
| |
| private: |
| First m_aValueToCompareWith; |
| }; |
| |
| /** can be used to find a certain value in a map |
| |
| ::std::find_if( aMap.begin(), aMap.end(), |
| SecondOfPairEquals< string, int >( 42 )); |
| */ |
| template< typename Key, typename Value > |
| class SecondOfPairEquals : public ::std::unary_function< ::std::pair< Key, Value >, bool > |
| { |
| public: |
| SecondOfPairEquals( const Value & aVal ) |
| : m_aValueToCompareWith( aVal ) |
| {} |
| bool operator() ( const ::std::pair< Key, Value > & rMapElem ) |
| { |
| return rMapElem.second == m_aValueToCompareWith; |
| } |
| |
| private: |
| Value m_aValueToCompareWith; |
| }; |
| |
| /** Searches for data in a given map, i.e. not for the key but for the data |
| pointed to by the keys. |
| |
| To find a key (value) you can use rMap.find( rValue ) |
| */ |
| template< class MapType > |
| inline typename MapType::const_iterator |
| findValueInMap( const MapType & rMap, const typename MapType::mapped_type & rData ) |
| { |
| return ::std::find_if( rMap.begin(), rMap.end(), |
| ::std::compose1( ::std::bind2nd( |
| ::std::equal_to< typename MapType::mapped_type >(), |
| rData ), |
| ::std::select2nd< typename MapType::value_type >())); |
| } |
| |
| /** Functor that deletes the object behind the given pointer by calling the |
| delete operator |
| */ |
| template< typename T > |
| struct DeletePtr : public ::std::unary_function< T *, void > |
| { |
| void operator() ( T * pObj ) |
| { delete pObj; } |
| }; |
| |
| } // namespace CommonFunctors |
| } // namespace chart |
| |
| // CHART2_COMMONFUNCTORS_HXX |
| #endif |