ucb/source/inc/regexpmap.tpt

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