ucb/source/inc/regexpmap.tpt

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 #ifndef _UCB_REGEXPMAP_TPT_
  20 #define _UCB_REGEXPMAP_TPT_
  21
  22 #include <regexpmap.hxx>
  23 #include <list>
  24 #include <rtl/ustring.hxx>
  25
  26 #include "regexp.hxx"
  27
  28 using namespace ucb_impl;
  29
  30 namespace ucb_impl {
  31
  32 //============================================================================
  33
  34 template< typename Val >
  35 struct Entry
  36 {
  37         Regexp m_aRegexp;
  38         Val m_aValue;
  39
  40         inline Entry(Regexp const & rTheRegexp, Val const & rTheValue):
  41                 m_aRegexp(rTheRegexp), m_aValue(rTheValue) {}
  42 };
  43
  44 //============================================================================
  45 template< typename Val > class List: public std::list< Entry< Val > > {};
  46
  47 //============================================================================
  48 //
  49 //  RegexpMapIterImpl
  50 //
  51 //============================================================================
  52
  53 template< typename Val >
  54 class RegexpMapIterImpl
  55 {
  56 public:
  57         typedef RegexpMapImpl< Val > MapImpl;
  58         typedef typename List< Val >::iterator ListIterator;
  59
  60         // Solaris needs these for the ctor...
  61
  62         inline RegexpMapIterImpl();
  63
  64         inline RegexpMapIterImpl(MapImpl * pTheMap, int nTheList,
  65                                                          ListIterator aTheIndex);
  66
  67         RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap, bool bBegin);
  68
  69         RegexpMapIterImpl(RegexpMapIterImpl const & rOther);
  70
  71         RegexpMapIterImpl & operator =(RegexpMapIterImpl const & rOther);
  72
  73         bool operator ==(RegexpMapIterImpl const & rOther) const;
  74
  75         RegexpMapImpl< Val > const * getMap() const { return m_pMap; }
  76
  77         int getList() const { return m_nList; }
  78
  79         typename List< Val >::iterator const & getIndex() const { return m_aIndex; }
  80
  81         void next();
  82
  83         RegexpMapEntry< Val > & get();
  84
  85 private:
  86         mutable RegexpMapEntry< Val > m_aEntry;
  87         typename List< Val >::iterator m_aIndex;
  88         RegexpMapImpl< Val > * m_pMap;
  89         int m_nList;
  90         mutable bool m_bEntrySet;
  91
  92         void setEntry() const;
  93 };
  94
  95 }
  96
  97 template< typename Val >
  98 inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
  99         m_aEntry(rtl::OUString(), 0),
 100         m_pMap(0),
 101         m_nList(-1),
 102         m_bEntrySet(false)
 103 {}
 104
 105 template< typename Val >
 106 inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(MapImpl * pTheMap,
 107                                                                                                    int nTheList,
 108                                                                                                    ListIterator aTheIndex):
 109         m_aEntry(rtl::OUString(), 0),
 110         m_aIndex(aTheIndex),
 111         m_pMap(pTheMap),
 112         m_nList(nTheList),
 113         m_bEntrySet(false)
 114 {}
 115
 116 //============================================================================
 117 template< typename Val >
 118 void RegexpMapIterImpl< Val >::setEntry() const
 119 {
 120         if (!m_bEntrySet)
 121         {
 122                 Entry< Val > const & rTheEntry
 123                         = m_nList == -1 ? *m_pMap->m_pDefault : *m_aIndex;
 124                 m_aEntry
 125                         = RegexpMapEntry< Val >(rTheEntry.m_aRegexp.getRegexp(false),
 126                                                                         const_cast< Val * >(&rTheEntry.m_aValue));
 127                 m_bEntrySet = true;
 128         }
 129 }
 130
 131 //============================================================================
 132 template< typename Val >
 133 RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap,
 134                                                                                         bool bBegin):
 135         m_aEntry(rtl::OUString(), 0),
 136         m_pMap(pTheMap),
 137         m_bEntrySet(false)
 138 {
 139         if (bBegin)
 140         {
 141                 m_nList = -1;
 142                 if (!m_pMap->m_pDefault)
 143                         next();
 144         }
 145         else
 146         {
 147                 m_nList = Regexp::KIND_DOMAIN;
 148                 m_aIndex = m_pMap->m_aList[Regexp::KIND_DOMAIN].end();
 149         }
 150 }
 151
 152 //============================================================================
 153 template< typename Val >
 154 RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapIterImpl const & rOther):
 155     m_aEntry(rOther.m_aEntry), m_pMap(rOther.m_pMap), m_nList(rOther.m_nList),
 156     m_bEntrySet(rOther.m_bEntrySet)
 157 {
 158     if (m_nList != -1)
 159         m_aIndex = rOther.m_aIndex;
 160 }
 161
 162 //============================================================================
 163 template< typename Val >
 164 RegexpMapIterImpl< Val > & RegexpMapIterImpl< Val >::operator =(
 165     RegexpMapIterImpl const & rOther)
 166 {
 167     if (this != &rOther)
 168     {
 169         m_aEntry = rOther.m_aEntry;
 170         m_pMap = rOther.m_pMap;
 171         m_nList = rOther.m_nList;
 172         m_bEntrySet = rOther.m_bEntrySet;
 173         if (m_nList == -1)
 174             m_aIndex = typename List< Val >::iterator();
 175         else
 176             m_aIndex = rOther.m_aIndex;
 177     }
 178     return *this;
 179 }
 180
 181 //============================================================================
 182 template< typename Val >
 183 bool RegexpMapIterImpl< Val >::operator ==(RegexpMapIterImpl const & rOther)
 184         const
 185 {
 186         return m_pMap == rOther.m_pMap
 187                    && m_nList == rOther.m_nList
 188                    && (m_nList == -1 || m_aIndex == rOther.m_aIndex);
 189 }
 190
 191 //============================================================================
 192 template< typename Val >
 193 void RegexpMapIterImpl< Val >::next()
 194 {
 195         switch (m_nList)
 196         {
 197                 case Regexp::KIND_DOMAIN:
 198                         if (m_aIndex == m_pMap->m_aList[m_nList].end())
 199                                 return;
 200                 default:
 201                         ++m_aIndex;
 202                         if (m_nList == Regexp::KIND_DOMAIN
 203                                 || m_aIndex != m_pMap->m_aList[m_nList].end())
 204                                 break;
 205                 case -1:
 206                         do
 207                         {
 208                                 ++m_nList;
 209                                 m_aIndex = m_pMap->m_aList[m_nList].begin();
 210                         }
 211                         while (m_nList < Regexp::KIND_DOMAIN
 212                                    && m_aIndex == m_pMap->m_aList[m_nList].end());
 213                         break;
 214         }
 215         m_bEntrySet = false;
 216 }
 217
 218 //============================================================================
 219 template< typename Val >
 220 RegexpMapEntry< Val > & RegexpMapIterImpl< Val >::get()
 221 {
 222         setEntry();
 223         return m_aEntry;
 224 }
 225
 226 //============================================================================
 227 //
 228 //  RegexpMapConstIter
 229 //
 230 //============================================================================
 231
 232 template< typename Val >
 233 RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapIterImpl< Val > *
 234                                                                                               pTheImpl):
 235         m_pImpl(pTheImpl)
 236 {}
 237
 238 //============================================================================
 239 template< typename Val >
 240 RegexpMapConstIter< Val >::RegexpMapConstIter():
 241         m_pImpl(new RegexpMapIterImpl< Val >)
 242 {}
 243
 244 //============================================================================
 245 template< typename Val >
 246 RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapConstIter const &
 247                                                                                               rOther):
 248         m_pImpl(new RegexpMapIterImpl< Val >(*rOther.m_pImpl))
 249 {}
 250
 251 //============================================================================
 252 template< typename Val >
 253 RegexpMapConstIter< Val >::~RegexpMapConstIter()
 254 {
 255         delete m_pImpl;
 256 }
 257
 258 //============================================================================
 259 template< typename Val >
 260 RegexpMapConstIter< Val > &
 261 RegexpMapConstIter< Val >::operator =(RegexpMapConstIter const & rOther)
 262 {
 263         *m_pImpl = *rOther.m_pImpl;
 264         return *this;
 265 }
 266
 267 //============================================================================
 268 template< typename Val >
 269 RegexpMapConstIter< Val > & RegexpMapConstIter< Val >::operator ++()
 270 {
 271         m_pImpl->next();
 272         return *this;
 273 }
 274
 275 //============================================================================
 276 template< typename Val >
 277 RegexpMapConstIter< Val > RegexpMapConstIter< Val >::operator ++(int)
 278 {
 279         RegexpMapConstIter aTemp(*this);
 280         m_pImpl->next();
 281         return aTemp;
 282 }
 283
 284 //============================================================================
 285 template< typename Val >
 286 RegexpMapEntry< Val > const & RegexpMapConstIter< Val >::operator *() const
 287 {
 288         return m_pImpl->get();
 289 }
 290
 291 //============================================================================
 292 template< typename Val >
 293 RegexpMapEntry< Val > const * RegexpMapConstIter< Val >::operator ->() const
 294 {
 295         return &m_pImpl->get();
 296 }
 297
 298 //============================================================================
 299 template< typename Val >
 300 bool RegexpMapConstIter< Val >::equals(RegexpMapConstIter const & rOther)
 301         const
 302 {
 303         return *m_pImpl == *rOther.m_pImpl;
 304 }
 305
 306 //============================================================================
 307 //
 308 //  RegexpMapIter
 309 //
 310 //============================================================================
 311
 312 template< typename Val >
 313 RegexpMapIter< Val >::RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl):
 314         RegexpMapConstIter< Val >(pTheImpl)
 315 {}
 316
 317 //============================================================================
 318 template< typename Val >
 319 RegexpMapIter< Val > & RegexpMapIter< Val >::operator ++()
 320 {
 321         this->m_pImpl->next();
 322         return *this;
 323 }
 324
 325 //============================================================================
 326 template< typename Val >
 327 RegexpMapIter< Val > RegexpMapIter< Val >::operator ++(int)
 328 {
 329         RegexpMapIter aTemp(*this);
 330         this->m_pImpl->next();
 331         return aTemp;
 332 }
 333
 334 //============================================================================
 335 template< typename Val >
 336 RegexpMapEntry< Val > & RegexpMapIter< Val >::operator *()
 337 {
 338         return this->m_pImpl->get();
 339 }
 340
 341 //============================================================================
 342 template< typename Val >
 343 RegexpMapEntry< Val > const & RegexpMapIter< Val >::operator *() const
 344 {
 345         return this->m_pImpl->get();
 346 }
 347
 348 //============================================================================
 349 template< typename Val >
 350 RegexpMapEntry< Val > * RegexpMapIter< Val >::operator ->()
 351 {
 352         return &this->m_pImpl->get();
 353 }
 354
 355 //============================================================================
 356 template< typename Val >
 357 RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
 358 {
 359         return &this->m_pImpl->get();
 360 }
 361
 362 //============================================================================
 363 //
 364 //  RegexpMap
 365 //
 366 //============================================================================
 367
 368 namespace ucb_impl {
 369
 370 template< typename Val >
 371 struct RegexpMapImpl
 372 {
 373         List< Val > m_aList[Regexp::KIND_DOMAIN + 1];
 374         Entry< Val > * m_pDefault;
 375
 376         RegexpMapImpl(): m_pDefault(0) {}
 377
 378         ~RegexpMapImpl() { delete m_pDefault; }
 379 };
 380
 381 }
 382
 383 //============================================================================
 384 template< typename Val >
 385 RegexpMap< Val >::RegexpMap():
 386         m_pImpl(new RegexpMapImpl< Val >)
 387 {}
 388
 389 //============================================================================
 390 template< typename Val >
 391 RegexpMap< Val >::RegexpMap(RegexpMap const & rOther):
 392         m_pImpl(new RegexpMapImpl< Val >(*rOther.m_pImpl))
 393 {}
 394
 395 //============================================================================
 396 template< typename Val >
 397 RegexpMap< Val >::~RegexpMap()
 398 {
 399         delete m_pImpl;
 400 }
 401
 402 //============================================================================
 403 template< typename Val >
 404 RegexpMap< Val > & RegexpMap< Val >::operator =(RegexpMap const & rOther)
 405 {
 406         *m_pImpl = *rOther.m_pImpl;
 407         return *this;
 408 }
 409
 410 //============================================================================
 411 template< typename Val >
 412 bool RegexpMap< Val >::add(rtl::OUString const & rKey, Val const & rValue,
 413                                                    bool bOverwrite, rtl::OUString * pReverse)
 414 {
 415         Regexp aRegexp(Regexp::parse(rKey));
 416
 417         if (aRegexp.isDefault())
 418         {
 419                 if (m_pImpl->m_pDefault)
 420                 {
 421                         if (!bOverwrite)
 422                                 return false;
 423                         delete m_pImpl->m_pDefault;
 424                 }
 425                 m_pImpl->m_pDefault = new Entry< Val >(aRegexp, rValue);
 426         }
 427         else
 428         {
 429                 List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
 430
 431                 typename List< Val >::iterator aEnd(rTheList.end());
 432                 for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
 433                 {
 434                         if (aIt->m_aRegexp == aRegexp)
 435                         {
 436                                 if (bOverwrite)
 437                                 {
 438                                         rTheList.erase(aIt);
 439                                         break;
 440                                 }
 441                                 else
 442                                         return false;
 443                         }
 444                 }
 445
 446                 rTheList.push_back(Entry< Val >(aRegexp, rValue));
 447         }
 448
 449         if (pReverse)
 450                 *pReverse = aRegexp.getRegexp(true);
 451
 452         return true;
 453 }
 454
 455 //============================================================================
 456 template< typename Val >
 457 typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const & rKey,
 458                                                                                                   rtl::OUString * pReverse)
 459 {
 460         Regexp aRegexp(Regexp::parse(rKey));
 461
 462         if (pReverse)
 463                 *pReverse = aRegexp.getRegexp(true);
 464
 465         if (aRegexp.isDefault())
 466         {
 467                 if (m_pImpl->m_pDefault)
 468                         return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
 469                                                                                                                                          true));
 470         }
 471         else
 472         {
 473                 List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
 474
 475                 typename List< Val > ::iterator aEnd(rTheList.end());
 476                 for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
 477                         if (aIt->m_aRegexp == aRegexp)
 478                                 return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(
 479                                                                         m_pImpl,
 480                                                                                                         aRegexp.getKind(), aIt));
 481         }
 482
 483         return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
 484 }
 485
 486 //============================================================================
 487 template< typename Val >
 488 void RegexpMap< Val >::erase(iterator const & rPos)
 489 {
 490         if (rPos.m_pImpl->getMap() == m_pImpl)
 491         {
 492                 if (rPos.m_pImpl->getList() == -1)
 493                 {
 494                         if (m_pImpl->m_pDefault)
 495                         {
 496                                 delete m_pImpl->m_pDefault;
 497                                 m_pImpl->m_pDefault = 0;
 498                         }
 499                 }
 500                 else
 501                         m_pImpl->m_aList[rPos.m_pImpl->getList()].
 502                                          erase(rPos.m_pImpl->getIndex());
 503         }
 504 }
 505
 506 //============================================================================
 507 template< typename Val >
 508 typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
 509 {
 510         return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, true));
 511 }
 512
 513 //============================================================================
 514 template< typename Val >
 515 typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
 516 {
 517         return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
 518                                                                                                                                   true));
 519 }
 520
 521 //============================================================================
 522 template< typename Val >
 523 typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
 524 {
 525         return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
 526 }
 527
 528 //============================================================================
 529 template< typename Val >
 530 typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
 531 {
 532         return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
 533                                                                                                                                   false));
 534 }
 535
 536 //============================================================================
 537 template< typename Val >
 538 bool RegexpMap< Val >::empty() const
 539 {
 540         return !m_pImpl->m_pDefault
 541                    && m_pImpl->m_aList[Regexp::KIND_PREFIX].empty()
 542                    && m_pImpl->m_aList[Regexp::KIND_AUTHORITY].empty()
 543                    && m_pImpl->m_aList[Regexp::KIND_DOMAIN].empty();
 544 }
 545
 546 //============================================================================
 547 template< typename Val >
 548 typename RegexpMap< Val >::size_type RegexpMap< Val >::size() const
 549 {
 550         return (m_pImpl->m_pDefault ? 1 : 0)
 551                        + m_pImpl->m_aList[Regexp::KIND_PREFIX].size()
 552                        + m_pImpl->m_aList[Regexp::KIND_AUTHORITY].size()
 553                        + m_pImpl->m_aList[Regexp::KIND_DOMAIN].size();
 554 }
 555
 556 //============================================================================
 557 template< typename Val >
 558 Val const * RegexpMap< Val >::map(rtl::OUString const & rString,
 559                                                                   rtl::OUString * pTranslation,
 560                                                                   bool * pTranslated) const
 561 {
 562         for (int n = Regexp::KIND_DOMAIN; n >= Regexp::KIND_PREFIX; --n)
 563         {
 564                 List< Val > const & rTheList = m_pImpl->m_aList[n];
 565
 566                 typename List< Val >::const_iterator aEnd(rTheList.end());
 567                 for (typename List< Val >::const_iterator aIt(rTheList.begin()); aIt != aEnd;
 568                          ++aIt)
 569                         if (aIt->m_aRegexp.matches(rString, pTranslation, pTranslated))
 570                                 return &aIt->m_aValue;
 571         }
 572         if (m_pImpl->m_pDefault
 573                 && m_pImpl->m_pDefault->m_aRegexp.matches(rString, pTranslation,
 574                                                                                                   pTranslated))
 575                 return &m_pImpl->m_pDefault->m_aValue;
 576         return 0;
 577 }
 578
 579 #endif // _UCB_REGEXPMAP_TPT_