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