include/comphelper/stl_types.hxx

   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 _COMPHELPER_STLTYPES_HXX_
  20 #define _COMPHELPER_STLTYPES_HXX_
  21
  22 #include "sal/config.h"
  23
  24 #include <vector>
  25 #include <map>
  26
  27 #include <stack>
  28 #include <set>
  29
  30 #include <math.h> // prevent conflict between exception and std::exception
  31 #include <functional>
  32
  33
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <com/sun/star/uno/Reference.hxx>
  37 #include <com/sun/star/beans/PropertyValue.hpp>
  38 #include <com/sun/star/beans/NamedValue.hpp>
  39
  40 //... namespace comphelper ................................................
  41 namespace comphelper
  42 {
  43 //.........................................................................
  44
  45 //========================================================================
  46 // comparison functors
  47
  48 //------------------------------------------------------------------------
  49 struct UStringLess : public ::std::binary_function< OUString, OUString, bool>
  50 {
  51     bool operator() (const OUString& x, const OUString& y) const { return x < y ? true : false;}      // construct prevents a MSVC6 warning
  52 };
  53 //------------------------------------------------------------------------
  54 struct UStringMixLess : public ::std::binary_function< OUString, OUString, bool>
  55 {
  56     bool m_bCaseSensitive;
  57 public:
  58     UStringMixLess(bool bCaseSensitive = true):m_bCaseSensitive(bCaseSensitive){}
  59     bool operator() (const OUString& x, const OUString& y) const
  60     {
  61         if (m_bCaseSensitive)
  62             return rtl_ustr_compare(x.getStr(), y.getStr()) < 0 ? true : false;
  63         else
  64             return rtl_ustr_compareIgnoreAsciiCase(x.getStr(), y.getStr()) < 0 ? true : false;
  65     }
  66
  67     bool isCaseSensitive() const {return m_bCaseSensitive;}
  68 };
  69 //------------------------------------------------------------------------
  70 struct UStringEqual
  71 {
  72     sal_Bool operator() (const OUString& lhs, const OUString& rhs) const { return lhs.equals( rhs );}
  73 };
  74
  75 //------------------------------------------------------------------------
  76 struct UStringIEqual
  77 {
  78     sal_Bool operator() (const OUString& lhs, const OUString& rhs) const { return lhs.equalsIgnoreAsciiCase( rhs );}
  79 };
  80
  81 //------------------------------------------------------------------------
  82 class UStringMixEqual
  83 {
  84     sal_Bool m_bCaseSensitive;
  85
  86 public:
  87     UStringMixEqual(sal_Bool bCaseSensitive = sal_True):m_bCaseSensitive(bCaseSensitive){}
  88     sal_Bool operator() (const OUString& lhs, const OUString& rhs) const
  89     {
  90         return m_bCaseSensitive ? lhs.equals( rhs ) : lhs.equalsIgnoreAsciiCase( rhs );
  91     }
  92     sal_Bool isCaseSensitive() const {return m_bCaseSensitive;}
  93 };
  94 //------------------------------------------------------------------------
  95 class TStringMixEqualFunctor : public ::std::binary_function< OUString,OUString,bool>
  96 {
  97     sal_Bool m_bCaseSensitive;
  98
  99 public:
 100     TStringMixEqualFunctor(sal_Bool bCaseSensitive = sal_True)
 101         :m_bCaseSensitive(bCaseSensitive)
 102     {}
 103     bool operator() (const OUString& lhs, const OUString& rhs) const
 104     {
 105         return !!(m_bCaseSensitive ? lhs.equals( rhs ) : lhs.equalsIgnoreAsciiCase( rhs ));
 106     }
 107     sal_Bool isCaseSensitive() const {return m_bCaseSensitive;}
 108 };
 109 //------------------------------------------------------------------------
 110 class TPropertyValueEqualFunctor : public ::std::binary_function< ::com::sun::star::beans::PropertyValue,OUString,bool>
 111 {
 112 public:
 113     TPropertyValueEqualFunctor()
 114     {}
 115     bool operator() (const ::com::sun::star::beans::PropertyValue& lhs, const OUString& rhs) const
 116     {
 117         return !!(lhs.Name == rhs);
 118     }
 119 };
 120 //------------------------------------------------------------------------
 121 class TNamedValueEqualFunctor : public ::std::binary_function< ::com::sun::star::beans::NamedValue,OUString,bool>
 122 {
 123 public:
 124     TNamedValueEqualFunctor()
 125     {}
 126     bool operator() (const ::com::sun::star::beans::NamedValue& lhs, const OUString& rhs) const
 127     {
 128         return !!(lhs.Name == rhs);
 129     }
 130 };
 131 //------------------------------------------------------------------------
 132 class UStringMixHash
 133 {
 134     sal_Bool m_bCaseSensitive;
 135
 136 public:
 137     UStringMixHash(sal_Bool bCaseSensitive = sal_True):m_bCaseSensitive(bCaseSensitive){}
 138     size_t operator() (const OUString& rStr) const
 139     {
 140         return m_bCaseSensitive ? rStr.hashCode() : rStr.toAsciiUpperCase().hashCode();
 141     }
 142     sal_Bool isCaseSensitive() const {return m_bCaseSensitive;}
 143 };
 144
 145 //=====================================================================
 146 //= OInterfaceCompare
 147 //=====================================================================
 148 /** is stl-compliant structure for comparing Reference&lt; &lt;iface&gt; &gt; instances
 149 */
 150 template < class IAFCE >
 151 struct OInterfaceCompare
 152     :public ::std::binary_function  <   ::com::sun::star::uno::Reference< IAFCE >
 153                                     ,   ::com::sun::star::uno::Reference< IAFCE >
 154                                     ,   bool
 155                                     >
 156 {
 157     bool operator() (const ::com::sun::star::uno::Reference< IAFCE >& lhs, const ::com::sun::star::uno::Reference< IAFCE >& rhs) const
 158     {
 159         return lhs.get() < rhs.get();
 160             // this does not make any sense if you see the semantics of the pointer returned by get:
 161             // It's a pointer to a point in memory where an interface implementation lies.
 162             // But for our purpose (provide a reliable less-operator which can be used with the STL), this is
 163             // sufficient ....
 164     }
 165 };
 166
 167 template <class _Tp, class _Arg>
 168 class mem_fun1_t : public ::std::binary_function<_Tp*,_Arg,void>
 169 {
 170     typedef void (_Tp::*_fun_type)(_Arg);
 171 public:
 172     explicit mem_fun1_t(_fun_type __pf) : _M_f(__pf) {}
 173     void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 174 private:
 175     _fun_type _M_f;
 176 };
 177
 178 template <class _Tp, class _Arg>
 179 inline mem_fun1_t<_Tp,_Arg> mem_fun(void (_Tp::*__f)(_Arg))
 180 {
 181     return mem_fun1_t<_Tp,_Arg>(__f);
 182 }
 183
 184 //.........................................................................
 185 /** output iterator that appends OUStrings into an OUStringBuffer.
 186  */
 187 class OUStringBufferAppender :
 188     public ::std::iterator< ::std::output_iterator_tag, void, void, void, void>
 189 {
 190 public:
 191     typedef OUStringBufferAppender Self;
 192     typedef ::std::output_iterator_tag iterator_category;
 193     typedef void value_type;
 194     typedef void reference;
 195     typedef void pointer;
 196     typedef size_t difference_type;
 197
 198     OUStringBufferAppender(OUStringBuffer & i_rBuffer)
 199         : m_rBuffer(i_rBuffer) { }
 200     Self & operator=(OUString const & i_rStr)
 201     {
 202         m_rBuffer.append( i_rStr );
 203         return *this;
 204     }
 205     Self & operator*() { return *this; } // so operator= works
 206     Self & operator++() { return *this; }
 207     Self & operator++(int) { return *this; }
 208
 209 private:
 210     OUStringBuffer & m_rBuffer;
 211 };
 212
 213 //.........................................................................
 214 /** algorithm similar to std::copy, but inserts a separator between elements.
 215  */
 216 template< typename ForwardIter, typename OutputIter, typename T >
 217 OutputIter intersperse(
 218     ForwardIter start, ForwardIter end, OutputIter out, T const & separator)
 219 {
 220     if (start != end) {
 221         *out = *start;
 222         ++start;
 223         ++out;
 224     }
 225
 226     while (start != end) {
 227         *out = separator;
 228         ++out;
 229         *out = *start;
 230         ++start;
 231         ++out;
 232     }
 233
 234     return out;
 235 }
 236
 237 //.........................................................................
 238 }
 239 //... namespace comphelper ................................................
 240
 241 //==================================================================
 242 // consistently defining stl-types
 243 //==================================================================
 244
 245 #define DECLARE_STL_ITERATORS(classname)                            \
 246     typedef classname::iterator         classname##Iterator;        \
 247     typedef classname::const_iterator   Const##classname##Iterator  \
 248
 249 #define DECLARE_STL_MAP(keytype, valuetype, comparefct, classname)  \
 250     typedef std::map< keytype, valuetype, comparefct >  classname;  \
 251     DECLARE_STL_ITERATORS(classname)                                \
 252
 253 #define DECLARE_STL_STDKEY_MAP(keytype, valuetype, classname)               \
 254     DECLARE_STL_MAP(keytype, valuetype, std::less< keytype >, classname)    \
 255
 256 #define DECLARE_STL_VECTOR(valuetyp, classname)     \
 257     typedef std::vector< valuetyp >     classname;  \
 258     DECLARE_STL_ITERATORS(classname)                \
 259
 260 #define DECLARE_STL_USTRINGACCESS_MAP(valuetype, classname)                 \
 261     DECLARE_STL_MAP(OUString, valuetype, ::comphelper::UStringLess, classname)   \
 262
 263 #define DECLARE_STL_STDKEY_SET(valuetype, classname)    \
 264     typedef ::std::set< valuetype > classname;          \
 265     DECLARE_STL_ITERATORS(classname)                    \
 266
 267 #define DECLARE_STL_SET(valuetype, comparefct, classname)               \
 268     typedef ::std::set< valuetype, comparefct > classname;  \
 269     DECLARE_STL_ITERATORS(classname)                        \
 270
 271 #endif  // _COMPHELPER_STLTYPES_HXX_
 272
 273 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */