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
20 #ifndef INCLUDED_UCB_SOURCE_INC_REGEXPMAP_HXX
21 #define INCLUDED_UCB_SOURCE_INC_REGEXPMAP_HXX
22
23 #include <sal/config.h>
24
25 #include <vector>
26 #include <memory>
27
28 #include <rtl/ustring.hxx>
29 #include <sal/types.h>
30
31 #include "regexp.hxx"
32
33 namespace ucb_impl {
34
35 template< typename Val > class RegexpMap;
36 template< typename Val > class RegexpMapIter;
37
38
39 template< typename Val >
40 class RegexpMapEntry
41 {
42 public:
RegexpMapEntry(OUString const & rTheRegexp,Val * pTheValue)43 RegexpMapEntry(OUString const & rTheRegexp,
44 Val * pTheValue):
45 m_aRegexp(rTheRegexp), m_pValue(pTheValue) {}
46
getRegexp() const47 const OUString& getRegexp() const { return m_aRegexp; }
48
getValue() const49 Val const & getValue() const { return *m_pValue; }
50
getValue()51 Val & getValue() { return *m_pValue; }
52
53 private:
54 OUString m_aRegexp;
55 Val * m_pValue;
56 };
57
58
59 template< typename Val >
60 struct Entry
61 {
62 Regexp m_aRegexp;
63 Val m_aValue;
64
Entryucb_impl::Entry65 Entry(Regexp const & rTheRegexp, Val const & rTheValue):
66 m_aRegexp(rTheRegexp), m_aValue(rTheValue) {}
67 };
68
69
70 template< typename Val >
71 class RegexpMapConstIter
72 {
73 friend class RegexpMap< Val >; // to access m_pImpl, ctor
74 friend class RegexpMapIter< Val >; // to access m_pImpl, ctor
75
76 public:
77 typedef typename std::vector< Entry< Val > >::iterator ListIterator;
78
79 RegexpMapConstIter();
80
81 RegexpMapConstIter(RegexpMap< Val > * pTheMap, bool bBegin);
82
83 RegexpMapConstIter(RegexpMap< Val > * pTheMap, int nTheList,
84 ListIterator aTheIndex);
85
86 RegexpMapConstIter(RegexpMapConstIter const & rOther);
87
88 RegexpMapConstIter & operator =(RegexpMapConstIter const & rOther);
89
90 RegexpMapConstIter & operator ++();
91
92 RegexpMapEntry< Val > const * operator ->() const;
93
94 bool equals(RegexpMapConstIter const & rOther) const;
95 // for free operator ==(), operator !=()
96
97 protected:
98 RegexpMapEntry< Val > & get() const;
99
100 private:
101 mutable RegexpMapEntry< Val > m_aEntry;
102 typename std::vector< Entry< Val > >::iterator m_aIndex;
103 RegexpMap< Val > * m_pMap;
104 int m_nList;
105 mutable bool m_bEntrySet;
106 };
107
108 template< typename Val >
RegexpMapConstIter()109 RegexpMapConstIter< Val >::RegexpMapConstIter():
110 m_aEntry(OUString(), 0),
111 m_pMap(nullptr),
112 m_nList(-1),
113 m_bEntrySet(false)
114 {}
115
116 template< typename Val >
RegexpMapConstIter(RegexpMap<Val> * pTheMap,bool bBegin)117 RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMap< Val > * pTheMap,
118 bool bBegin):
119 m_aEntry(OUString(), 0),
120 m_pMap(pTheMap),
121 m_bEntrySet(false)
122 {
123 if (bBegin)
124 {
125 m_nList = -1;
126 if (!m_pMap->m_pDefault)
127 operator++();
128 }
129 else
130 {
131 m_nList = Regexp::KIND_DOMAIN;
132 m_aIndex = m_pMap->m_aList[Regexp::KIND_DOMAIN].end();
133 }
134 }
135
136 template< typename Val >
RegexpMapConstIter(RegexpMap<Val> * pTheMap,int nTheList,ListIterator aTheIndex)137 inline RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMap< Val > * pTheMap,
138 int nTheList,
139 ListIterator aTheIndex):
140 m_aEntry(OUString(), 0),
141 m_aIndex(aTheIndex),
142 m_pMap(pTheMap),
143 m_nList(nTheList),
144 m_bEntrySet(false)
145 {}
146
147 template< typename Val >
RegexpMapConstIter(RegexpMapConstIter const & rOther)148 RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapConstIter const &
149 rOther):
150 m_aEntry(rOther.m_aEntry), m_pMap(rOther.m_pMap), m_nList(rOther.m_nList),
151 m_bEntrySet(rOther.m_bEntrySet)
152 {
153 if (m_nList != -1)
154 m_aIndex = rOther.m_aIndex;
155 }
156
157 template< typename Val >
158 RegexpMapConstIter< Val > &
operator =(RegexpMapConstIter const & rOther)159 RegexpMapConstIter< Val >::operator =(RegexpMapConstIter const & rOther)
160 {
161 if (this != &rOther)
162 {
163 m_aEntry = rOther.m_aEntry;
164 m_pMap = rOther.m_pMap;
165 m_nList = rOther.m_nList;
166 m_bEntrySet = rOther.m_bEntrySet;
167 if (m_nList == -1)
168 m_aIndex = typename std::vector< Entry<Val> >::iterator();
169 else
170 m_aIndex = rOther.m_aIndex;
171 }
172 return *this;
173 }
174
175 template< typename Val >
operator ++()176 RegexpMapConstIter< Val > & RegexpMapConstIter< Val >::operator ++()
177 {
178 switch (m_nList)
179 {
180 case Regexp::KIND_DOMAIN:
181 if (m_aIndex == m_pMap->m_aList[m_nList].end())
182 return *this;
183 [[fallthrough]];
184 default:
185 ++m_aIndex;
186 if (m_nList == Regexp::KIND_DOMAIN
187 || m_aIndex != m_pMap->m_aList[m_nList].end())
188 break;
189 [[fallthrough]];
190 case -1:
191 do
192 {
193 ++m_nList;
194 m_aIndex = m_pMap->m_aList[m_nList].begin();
195 }
196 while (m_nList < Regexp::KIND_DOMAIN
197 && m_aIndex == m_pMap->m_aList[m_nList].end());
198 break;
199 }
200 m_bEntrySet = false;
201 return *this;
202 }
203
204 template< typename Val >
get() const205 RegexpMapEntry< Val > & RegexpMapConstIter< Val >::get() const
206 {
207 if (!m_bEntrySet)
208 {
209 Entry< Val > const & rTheEntry
210 = m_nList == -1 ? *m_pMap->m_pDefault : *m_aIndex;
211 m_aEntry
212 = RegexpMapEntry< Val >(rTheEntry.m_aRegexp.getRegexp(),
213 const_cast< Val * >(&rTheEntry.m_aValue));
214 m_bEntrySet = true;
215 }
216 return m_aEntry;
217 }
218
219 template< typename Val >
operator ->() const220 RegexpMapEntry< Val > const * RegexpMapConstIter< Val >::operator ->() const
221 {
222 return &get();
223 }
224
225 template< typename Val >
equals(RegexpMapConstIter const & rOther) const226 bool RegexpMapConstIter< Val >::equals(RegexpMapConstIter const & rOther)
227 const
228 {
229 return m_pMap == rOther.m_pMap
230 && m_nList == rOther.m_nList
231 && (m_nList == -1 || m_aIndex == rOther.m_aIndex);
232 }
233
234
235 template< typename Val >
236 class RegexpMapIter: public RegexpMapConstIter< Val >
237 {
238 friend class RegexpMap< Val >; // to access ctor
239
240 public:
RegexpMapIter()241 RegexpMapIter() {}
242
RegexpMapIter(RegexpMap<Val> * pTheMap,bool bBegin)243 RegexpMapIter(RegexpMap< Val > * pTheMap, bool bBegin):
244 RegexpMapConstIter<Val>(pTheMap, bBegin)
245 {}
246
RegexpMapIter(RegexpMap<Val> * pTheMap,int nTheList,typename RegexpMapConstIter<Val>::ListIterator aTheIndex)247 RegexpMapIter(RegexpMap< Val > * pTheMap, int nTheList, typename RegexpMapConstIter< Val >::ListIterator aTheIndex):
248 RegexpMapConstIter<Val>(pTheMap, nTheList, aTheIndex)
249 {}
250
251 RegexpMapEntry< Val > * operator ->();
252
253 RegexpMapEntry< Val > const * operator ->() const;
254 };
255
256 template< typename Val >
operator ->()257 RegexpMapEntry< Val > * RegexpMapIter< Val >::operator ->()
258 {
259 return &RegexpMapConstIter<Val>::get();
260 }
261
262 template< typename Val >
operator ->() const263 RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
264 {
265 return &RegexpMapConstIter<Val>::get();
266 }
267
268
269 template< typename Val >
270 class RegexpMap
271 {
272 friend class RegexpMapConstIter<Val>;
273 public:
274 typedef sal_uInt32 size_type;
275 typedef RegexpMapIter< Val > iterator;
276 typedef RegexpMapConstIter< Val > const_iterator;
277
278 void add(OUString const & rKey, Val const & rValue);
279
280 iterator find(OUString const & rKey);
281
282 void erase(iterator const & rPos);
283
284 iterator begin();
285
286 const_iterator begin() const;
287
288 iterator end();
289
290 const_iterator end() const;
291
292 size_type size() const;
293
294 Val const * map(OUString const & rString) const;
295
296 private:
297 std::vector< Entry<Val> > m_aList[Regexp::KIND_DOMAIN + 1];
298 std::unique_ptr<Entry< Val >> m_pDefault;
299 };
300
301 template< typename Val >
add(OUString const & rKey,Val const & rValue)302 void RegexpMap< Val >::add(OUString const & rKey, Val const & rValue)
303 {
304 Regexp aRegexp(Regexp::parse(rKey));
305
306 if (aRegexp.isDefault())
307 {
308 if (m_pDefault)
309 {
310 return;
311 }
312 m_pDefault.reset( new Entry< Val >(aRegexp, rValue) );
313 }
314 else
315 {
316 std::vector< Entry<Val> > & rTheList = m_aList[aRegexp.getKind()];
317
318 for (auto const& elem : rTheList)
319 {
320 if (elem.m_aRegexp == aRegexp)
321 {
322 return;
323 }
324 }
325
326 rTheList.push_back(Entry< Val >(aRegexp, rValue));
327 }
328 }
329
330 template< typename Val >
find(OUString const & rKey)331 typename RegexpMap< Val >::iterator RegexpMap< Val >::find(OUString const & rKey)
332 {
333 Regexp aRegexp(Regexp::parse(rKey));
334
335 if (aRegexp.isDefault())
336 {
337 if (m_pDefault)
338 return RegexpMapIter< Val >(this, true);
339 }
340 else
341 {
342 std::vector< Entry<Val> > & rTheList = m_aList[aRegexp.getKind()];
343
344 typename std::vector< Entry<Val> >::iterator aEnd(rTheList.end());
345 for (typename std::vector< Entry<Val> >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
346 if (aIt->m_aRegexp == aRegexp)
347 return RegexpMapIter< Val >(this, aRegexp.getKind(), aIt);
348 }
349
350 return RegexpMapIter< Val >(this, false);
351 }
352
353 template< typename Val >
erase(iterator const & rPos)354 void RegexpMap< Val >::erase(iterator const & rPos)
355 {
356 assert(rPos.m_pMap == this);
357 if (rPos.m_pMap == this)
358 {
359 if (rPos.m_nList == -1)
360 {
361 m_pDefault.reset();
362 }
363 else
364 m_aList[rPos.m_nList].erase(rPos.m_aIndex);
365 }
366 }
367
368 template< typename Val >
begin()369 typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
370 {
371 return RegexpMapIter< Val >(this, true);
372 }
373
374 template< typename Val >
begin() const375 typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
376 {
377 return RegexpMapConstIter< Val >(this, true);
378 }
379
380 template< typename Val >
end()381 typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
382 {
383 return RegexpMapIter< Val >(this, false);
384 }
385
386 template< typename Val >
end() const387 typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
388 {
389 return RegexpMapConstIter< Val >(this, false);
390 }
391
392 template< typename Val >
size() const393 typename RegexpMap< Val >::size_type RegexpMap< Val >::size() const
394 {
395 return (m_pDefault ? 1 : 0)
396 + m_aList[Regexp::KIND_PREFIX].size()
397 + m_aList[Regexp::KIND_AUTHORITY].size()
398 + m_aList[Regexp::KIND_DOMAIN].size();
399 }
400
401 template< typename Val >
map(OUString const & rString) const402 Val const * RegexpMap< Val >::map(OUString const & rString) const
403 {
404 for (int n = Regexp::KIND_DOMAIN; n >= Regexp::KIND_PREFIX; --n)
405 {
406 std::vector< Entry<Val> > const & rTheList = m_aList[n];
407
408 for (auto const & rItem : rTheList)
409 if (rItem.m_aRegexp.matches(rString))
410 return &rItem.m_aValue;
411 }
412 if (m_pDefault
413 && m_pDefault->m_aRegexp.matches(rString))
414 return &m_pDefault->m_aValue;
415 return 0;
416 }
417
418 }
419
420
421 template< typename Val >
operator ==(ucb_impl::RegexpMapConstIter<Val> const & rIter1,ucb_impl::RegexpMapConstIter<Val> const & rIter2)422 inline bool operator ==(ucb_impl::RegexpMapConstIter< Val > const & rIter1,
423 ucb_impl::RegexpMapConstIter< Val > const & rIter2)
424 {
425 return rIter1.equals(rIter2);
426 }
427
428 template< typename Val >
operator !=(ucb_impl::RegexpMapConstIter<Val> const & rIter1,ucb_impl::RegexpMapConstIter<Val> const & rIter2)429 inline bool operator !=(ucb_impl::RegexpMapConstIter< Val > const & rIter1,
430 ucb_impl::RegexpMapConstIter< Val > const & rIter2)
431 {
432 return !rIter1.equals(rIter2);
433 }
434
435 #endif // INCLUDED_UCB_SOURCE_INC_REGEXPMAP_HXX
436
437 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
438