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