LCOV - code coverage report
Current view: top level - ucb/source/inc - regexpmap.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 171 0.0 %
Date: 2014-04-14 Functions: 0 52 0.0 %
Legend: Lines: hit not hit

          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             : 
      20             : #ifndef _UCB_REGEXPMAP_HXX_
      21             : #define _UCB_REGEXPMAP_HXX_
      22             : 
      23             : #include "sal/config.h"
      24             : 
      25             : #include <list>
      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           0 : class RegexpMapEntry
      40             : {
      41             : public:
      42           0 :     inline RegexpMapEntry(OUString const & rTheRegexp,
      43             :                           Val * pTheValue):
      44           0 :         m_aRegexp(rTheRegexp), m_pValue(pTheValue) {}
      45             : 
      46           0 :     OUString getRegexp() const { return m_aRegexp; }
      47             : 
      48           0 :     Val const & getValue() const { return *m_pValue; }
      49             : 
      50           0 :     Val & getValue() { return *m_pValue; }
      51             : 
      52             : private:
      53             :     OUString m_aRegexp;
      54             :     Val * m_pValue;
      55             : };
      56             : 
      57             : 
      58             : 
      59             : template< typename Val >
      60           0 : struct Entry
      61             : {
      62             :     Regexp m_aRegexp;
      63             :     Val m_aValue;
      64             : 
      65           0 :     inline Entry(Regexp const & rTheRegexp, Val const & rTheValue):
      66           0 :         m_aRegexp(rTheRegexp), m_aValue(rTheValue) {}
      67             : };
      68             : 
      69             : 
      70           0 : template< typename Val > class List: public std::list< Entry< Val > > {};
      71             : 
      72             : 
      73             : template< typename Val >
      74             : struct RegexpMapImpl
      75             : {
      76             :     List< Val > m_aList[Regexp::KIND_DOMAIN + 1];
      77             :     Entry< Val > * m_pDefault;
      78             : 
      79           0 :     RegexpMapImpl(): m_pDefault(0) {}
      80             : 
      81           0 :     ~RegexpMapImpl() { delete m_pDefault; }
      82             : };
      83             : 
      84             : 
      85             : template< typename Val >
      86           0 : class RegexpMapIterImpl
      87             : {
      88             : public:
      89             :     typedef RegexpMapImpl< Val > MapImpl;
      90             :     typedef typename List< Val >::iterator ListIterator;
      91             : 
      92             :     // Solaris needs these for the ctor...
      93             : 
      94             :     inline RegexpMapIterImpl();
      95             : 
      96             :     inline RegexpMapIterImpl(MapImpl * pTheMap, int nTheList,
      97             :                              ListIterator aTheIndex);
      98             : 
      99             :     RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap, bool bBegin);
     100             : 
     101             :     RegexpMapIterImpl(RegexpMapIterImpl const & rOther);
     102             : 
     103             :     RegexpMapIterImpl & operator =(RegexpMapIterImpl const & rOther);
     104             : 
     105             :     bool operator ==(RegexpMapIterImpl const & rOther) const;
     106             : 
     107           0 :     RegexpMapImpl< Val > const * getMap() const { return m_pMap; }
     108             : 
     109           0 :     int getList() const { return m_nList; }
     110             : 
     111           0 :     typename List< Val >::iterator const & getIndex() const { return m_aIndex; }
     112             : 
     113             :     void next();
     114             : 
     115             :     RegexpMapEntry< Val > & get();
     116             : 
     117             : private:
     118             :     mutable RegexpMapEntry< Val > m_aEntry;
     119             :     typename List< Val >::iterator m_aIndex;
     120             :     RegexpMapImpl< Val > * m_pMap;
     121             :     int m_nList;
     122             :     mutable bool m_bEntrySet;
     123             : 
     124             :     void setEntry() const;
     125             : };
     126             : 
     127             : template< typename Val >
     128           0 : inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
     129             :     m_aEntry(rtl::OUString(), 0),
     130             :     m_pMap(0),
     131             :     m_nList(-1),
     132           0 :     m_bEntrySet(false)
     133           0 : {}
     134             : 
     135             : template< typename Val >
     136           0 : inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(MapImpl * pTheMap,
     137             :                                                    int nTheList,
     138             :                                                    ListIterator aTheIndex):
     139             :     m_aEntry(rtl::OUString(), 0),
     140             :     m_aIndex(aTheIndex),
     141             :     m_pMap(pTheMap),
     142             :     m_nList(nTheList),
     143           0 :     m_bEntrySet(false)
     144           0 : {}
     145             : 
     146             : template< typename Val >
     147           0 : void RegexpMapIterImpl< Val >::setEntry() const
     148             : {
     149           0 :     if (!m_bEntrySet)
     150             :     {
     151             :         Entry< Val > const & rTheEntry
     152           0 :             = m_nList == -1 ? *m_pMap->m_pDefault : *m_aIndex;
     153           0 :         m_aEntry
     154           0 :             = RegexpMapEntry< Val >(rTheEntry.m_aRegexp.getRegexp(false),
     155             :                                     const_cast< Val * >(&rTheEntry.m_aValue));
     156           0 :         m_bEntrySet = true;
     157             :     }
     158           0 : }
     159             : 
     160             : template< typename Val >
     161           0 : RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap,
     162             :                                             bool bBegin):
     163             :     m_aEntry(rtl::OUString(), 0),
     164             :     m_pMap(pTheMap),
     165           0 :     m_bEntrySet(false)
     166             : {
     167           0 :     if (bBegin)
     168             :     {
     169           0 :         m_nList = -1;
     170           0 :         if (!m_pMap->m_pDefault)
     171           0 :             next();
     172             :     }
     173             :     else
     174             :     {
     175           0 :         m_nList = Regexp::KIND_DOMAIN;
     176           0 :         m_aIndex = m_pMap->m_aList[Regexp::KIND_DOMAIN].end();
     177             :     }
     178           0 : }
     179             : 
     180             : template< typename Val >
     181           0 : RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapIterImpl const & rOther):
     182             :     m_aEntry(rOther.m_aEntry), m_pMap(rOther.m_pMap), m_nList(rOther.m_nList),
     183           0 :     m_bEntrySet(rOther.m_bEntrySet)
     184             : {
     185           0 :     if (m_nList != -1)
     186           0 :         m_aIndex = rOther.m_aIndex;
     187           0 : }
     188             : 
     189             : template< typename Val >
     190           0 : RegexpMapIterImpl< Val > & RegexpMapIterImpl< Val >::operator =(
     191             :     RegexpMapIterImpl const & rOther)
     192             : {
     193           0 :     if (this != &rOther)
     194             :     {
     195           0 :         m_aEntry = rOther.m_aEntry;
     196           0 :         m_pMap = rOther.m_pMap;
     197           0 :         m_nList = rOther.m_nList;
     198           0 :         m_bEntrySet = rOther.m_bEntrySet;
     199           0 :         if (m_nList == -1)
     200           0 :             m_aIndex = typename List< Val >::iterator();
     201             :         else
     202           0 :             m_aIndex = rOther.m_aIndex;
     203             :     }
     204           0 :     return *this;
     205             : }
     206             : 
     207             : template< typename Val >
     208           0 : bool RegexpMapIterImpl< Val >::operator ==(RegexpMapIterImpl const & rOther)
     209             :     const
     210             : {
     211             :     return m_pMap == rOther.m_pMap
     212             :            && m_nList == rOther.m_nList
     213           0 :            && (m_nList == -1 || m_aIndex == rOther.m_aIndex);
     214             : }
     215             : 
     216             : template< typename Val >
     217           0 : void RegexpMapIterImpl< Val >::next()
     218             : {
     219           0 :     switch (m_nList)
     220             :     {
     221             :         case Regexp::KIND_DOMAIN:
     222           0 :             if (m_aIndex == m_pMap->m_aList[m_nList].end())
     223           0 :                 return;
     224             :             //fall-through
     225             :         default:
     226           0 :             ++m_aIndex;
     227           0 :             if (m_nList == Regexp::KIND_DOMAIN
     228           0 :                 || m_aIndex != m_pMap->m_aList[m_nList].end())
     229           0 :                 break;
     230             :             //fall-through
     231             :         case -1:
     232           0 :             do
     233             :             {
     234           0 :                 ++m_nList;
     235           0 :                 m_aIndex = m_pMap->m_aList[m_nList].begin();
     236             :             }
     237             :             while (m_nList < Regexp::KIND_DOMAIN
     238           0 :                    && m_aIndex == m_pMap->m_aList[m_nList].end());
     239           0 :             break;
     240             :     }
     241           0 :     m_bEntrySet = false;
     242             : }
     243             : 
     244             : template< typename Val >
     245           0 : RegexpMapEntry< Val > & RegexpMapIterImpl< Val >::get()
     246             : {
     247           0 :     setEntry();
     248           0 :     return m_aEntry;
     249             : }
     250             : 
     251             : 
     252             : template< typename Val >
     253             : class RegexpMapConstIter
     254             : {
     255             :     friend class RegexpMap< Val >; // to access m_pImpl, ctor
     256             :     friend class RegexpMapIter< Val >; // to access m_pImpl, ctor
     257             : 
     258             : public:
     259             :     RegexpMapConstIter();
     260             : 
     261             :     RegexpMapConstIter(RegexpMapConstIter const & rOther);
     262             : 
     263             :     ~RegexpMapConstIter();
     264             : 
     265             :     RegexpMapConstIter & operator =(RegexpMapConstIter const & rOther);
     266             : 
     267             :     RegexpMapConstIter & operator ++();
     268             : 
     269             :     RegexpMapConstIter operator ++(int);
     270             : 
     271             :     RegexpMapEntry< Val > const & operator *() const;
     272             : 
     273             :     RegexpMapEntry< Val > const * operator ->() const;
     274             : 
     275             :     bool equals(RegexpMapConstIter const & rOther) const;
     276             :         // for free operator ==(), operator !=()
     277             : 
     278             : private:
     279             :     RegexpMapIterImpl< Val > * m_pImpl;
     280             : 
     281             :     RegexpMapConstIter(RegexpMapIterImpl< Val > * pTheImpl);
     282             : };
     283             : 
     284             : template< typename Val >
     285           0 : RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapIterImpl< Val > *
     286             :                                                   pTheImpl):
     287           0 :     m_pImpl(pTheImpl)
     288           0 : {}
     289             : 
     290             : template< typename Val >
     291           0 : RegexpMapConstIter< Val >::RegexpMapConstIter():
     292           0 :     m_pImpl(new RegexpMapIterImpl< Val >)
     293           0 : {}
     294             : 
     295             : template< typename Val >
     296           0 : RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapConstIter const &
     297             :                                                   rOther):
     298           0 :     m_pImpl(new RegexpMapIterImpl< Val >(*rOther.m_pImpl))
     299           0 : {}
     300             : 
     301             : template< typename Val >
     302           0 : RegexpMapConstIter< Val >::~RegexpMapConstIter()
     303             : {
     304           0 :     delete m_pImpl;
     305           0 : }
     306             : 
     307             : template< typename Val >
     308             : RegexpMapConstIter< Val > &
     309           0 : RegexpMapConstIter< Val >::operator =(RegexpMapConstIter const & rOther)
     310             : {
     311           0 :     *m_pImpl = *rOther.m_pImpl;
     312           0 :     return *this;
     313             : }
     314             : 
     315             : template< typename Val >
     316           0 : RegexpMapConstIter< Val > & RegexpMapConstIter< Val >::operator ++()
     317             : {
     318           0 :     m_pImpl->next();
     319           0 :     return *this;
     320             : }
     321             : 
     322             : template< typename Val >
     323             : RegexpMapConstIter< Val > RegexpMapConstIter< Val >::operator ++(int)
     324             : {
     325             :     RegexpMapConstIter aTemp(*this);
     326             :     m_pImpl->next();
     327             :     return aTemp;
     328             : }
     329             : 
     330             : template< typename Val >
     331             : RegexpMapEntry< Val > const & RegexpMapConstIter< Val >::operator *() const
     332             : {
     333             :     return m_pImpl->get();
     334             : }
     335             : 
     336             : template< typename Val >
     337           0 : RegexpMapEntry< Val > const * RegexpMapConstIter< Val >::operator ->() const
     338             : {
     339           0 :     return &m_pImpl->get();
     340             : }
     341             : 
     342             : template< typename Val >
     343           0 : bool RegexpMapConstIter< Val >::equals(RegexpMapConstIter const & rOther)
     344             :     const
     345             : {
     346           0 :     return *m_pImpl == *rOther.m_pImpl;
     347             : }
     348             : 
     349             : 
     350             : template< typename Val >
     351           0 : class RegexpMapIter: public RegexpMapConstIter< Val >
     352             : {
     353             :     friend class RegexpMap< Val >; // to access ctor
     354             : 
     355             : public:
     356           0 :     RegexpMapIter() {}
     357             : 
     358             :     RegexpMapIter & operator ++();
     359             : 
     360             :     RegexpMapIter operator ++(int);
     361             : 
     362             :     RegexpMapEntry< Val > & operator *();
     363             : 
     364             :     RegexpMapEntry< Val > const & operator *() const;
     365             : 
     366             :     RegexpMapEntry< Val > * operator ->();
     367             : 
     368             :     RegexpMapEntry< Val > const * operator ->() const;
     369             : 
     370             : private:
     371             :     RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl);
     372             : };
     373             : 
     374             : template< typename Val >
     375           0 : RegexpMapIter< Val >::RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl):
     376           0 :     RegexpMapConstIter< Val >(pTheImpl)
     377           0 : {}
     378             : 
     379             : template< typename Val >
     380             : RegexpMapIter< Val > & RegexpMapIter< Val >::operator ++()
     381             : {
     382             :     this->m_pImpl->next();
     383             :     return *this;
     384             : }
     385             : 
     386             : template< typename Val >
     387             : RegexpMapIter< Val > RegexpMapIter< Val >::operator ++(int)
     388             : {
     389             :     RegexpMapIter aTemp(*this);
     390             :     this->m_pImpl->next();
     391             :     return aTemp;
     392             : }
     393             : 
     394             : template< typename Val >
     395             : RegexpMapEntry< Val > & RegexpMapIter< Val >::operator *()
     396             : {
     397             :     return this->m_pImpl->get();
     398             : }
     399             : 
     400             : template< typename Val >
     401             : RegexpMapEntry< Val > const & RegexpMapIter< Val >::operator *() const
     402             : {
     403             :     return this->m_pImpl->get();
     404             : }
     405             : 
     406             : template< typename Val >
     407           0 : RegexpMapEntry< Val > * RegexpMapIter< Val >::operator ->()
     408             : {
     409           0 :     return &this->m_pImpl->get();
     410             : }
     411             : 
     412             : template< typename Val >
     413             : RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
     414             : {
     415             :     return &this->m_pImpl->get();
     416             : }
     417             : 
     418             : 
     419             : template< typename Val >
     420             : class RegexpMap
     421             : {
     422             : public:
     423             :     typedef sal_uInt32 size_type;
     424             :     typedef RegexpMapIter< Val > iterator;
     425             :     typedef RegexpMapConstIter< Val > const_iterator;
     426             : 
     427             :     RegexpMap();
     428             : 
     429             :     RegexpMap(RegexpMap const & rOther);
     430             : 
     431             :     ~RegexpMap();
     432             : 
     433             :     RegexpMap & operator =(RegexpMap const & rOther);
     434             : 
     435             :     bool add(OUString const & rKey, Val const & rValue, bool bOverwrite,
     436             :              OUString * pReverse = 0);
     437             :         // throws com::sun::star::lang::IllegalArgumentException
     438             : 
     439             :     iterator find(OUString const & rKey, OUString * pReverse = 0);
     440             :         // throws com::sun::star::lang::IllegalArgumentException
     441             : 
     442             :     void erase(iterator const & rPos);
     443             : 
     444             :     iterator begin();
     445             : 
     446             :     const_iterator begin() const;
     447             : 
     448             :     iterator end();
     449             : 
     450             :     const_iterator end() const;
     451             : 
     452             :     bool empty() const;
     453             : 
     454             :     size_type size() const;
     455             : 
     456             :     Val const * map(OUString const & rString,
     457             :                     OUString * pTranslation = 0, bool * pTranslated = 0)
     458             :         const;
     459             : 
     460             : private:
     461             :     RegexpMapImpl< Val > * m_pImpl;
     462             : };
     463             : 
     464             : template< typename Val >
     465           0 : RegexpMap< Val >::RegexpMap():
     466           0 :     m_pImpl(new RegexpMapImpl< Val >)
     467           0 : {}
     468             : 
     469             : template< typename Val >
     470             : RegexpMap< Val >::RegexpMap(RegexpMap const & rOther):
     471             :     m_pImpl(new RegexpMapImpl< Val >(*rOther.m_pImpl))
     472             : {}
     473             : 
     474             : template< typename Val >
     475           0 : RegexpMap< Val >::~RegexpMap()
     476             : {
     477           0 :     delete m_pImpl;
     478           0 : }
     479             : 
     480             : template< typename Val >
     481             : RegexpMap< Val > & RegexpMap< Val >::operator =(RegexpMap const & rOther)
     482             : {
     483             :     *m_pImpl = *rOther.m_pImpl;
     484             :     return *this;
     485             : }
     486             : 
     487             : template< typename Val >
     488           0 : bool RegexpMap< Val >::add(rtl::OUString const & rKey, Val const & rValue,
     489             :                            bool bOverwrite, rtl::OUString * pReverse)
     490             : {
     491           0 :     Regexp aRegexp(Regexp::parse(rKey));
     492             : 
     493           0 :     if (aRegexp.isDefault())
     494             :     {
     495           0 :         if (m_pImpl->m_pDefault)
     496             :         {
     497           0 :             if (!bOverwrite)
     498           0 :                 return false;
     499           0 :             delete m_pImpl->m_pDefault;
     500             :         }
     501           0 :         m_pImpl->m_pDefault = new Entry< Val >(aRegexp, rValue);
     502             :     }
     503             :     else
     504             :     {
     505           0 :         List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
     506             : 
     507           0 :         typename List< Val >::iterator aEnd(rTheList.end());
     508           0 :         for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
     509             :         {
     510           0 :             if (aIt->m_aRegexp == aRegexp)
     511             :             {
     512           0 :                 if (bOverwrite)
     513             :                 {
     514           0 :                     rTheList.erase(aIt);
     515           0 :                     break;
     516             :                 }
     517             :                 else
     518           0 :                     return false;
     519             :             }
     520             :         }
     521             : 
     522           0 :         rTheList.push_back(Entry< Val >(aRegexp, rValue));
     523             :     }
     524             : 
     525           0 :     if (pReverse)
     526           0 :         *pReverse = aRegexp.getRegexp(true);
     527             : 
     528           0 :     return true;
     529             : }
     530             : 
     531             : template< typename Val >
     532           0 : typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const & rKey,
     533             :                                                   rtl::OUString * pReverse)
     534             : {
     535           0 :     Regexp aRegexp(Regexp::parse(rKey));
     536             : 
     537           0 :     if (pReverse)
     538           0 :         *pReverse = aRegexp.getRegexp(true);
     539             : 
     540           0 :     if (aRegexp.isDefault())
     541             :     {
     542           0 :         if (m_pImpl->m_pDefault)
     543             :             return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
     544           0 :                                                                      true));
     545             :     }
     546             :     else
     547             :     {
     548           0 :         List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
     549             : 
     550           0 :         typename List< Val > ::iterator aEnd(rTheList.end());
     551           0 :         for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
     552           0 :             if (aIt->m_aRegexp == aRegexp)
     553             :                 return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(
     554             :                                                     m_pImpl,
     555           0 :                                                     aRegexp.getKind(), aIt));
     556             :     }
     557             : 
     558           0 :     return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
     559             : }
     560             : 
     561             : template< typename Val >
     562           0 : void RegexpMap< Val >::erase(iterator const & rPos)
     563             : {
     564           0 :     if (rPos.m_pImpl->getMap() == m_pImpl)
     565             :     {
     566           0 :         if (rPos.m_pImpl->getList() == -1)
     567             :         {
     568           0 :             if (m_pImpl->m_pDefault)
     569             :             {
     570           0 :                 delete m_pImpl->m_pDefault;
     571           0 :                 m_pImpl->m_pDefault = 0;
     572             :             }
     573             :         }
     574             :         else
     575           0 :             m_pImpl->m_aList[rPos.m_pImpl->getList()].
     576             :                          erase(rPos.m_pImpl->getIndex());
     577             :     }
     578           0 : }
     579             : 
     580             : template< typename Val >
     581           0 : typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
     582             : {
     583           0 :     return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, true));
     584             : }
     585             : 
     586             : template< typename Val >
     587             : typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
     588             : {
     589             :     return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
     590             :                                                                   true));
     591             : }
     592             : 
     593             : template< typename Val >
     594           0 : typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
     595             : {
     596           0 :     return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
     597             : }
     598             : 
     599             : template< typename Val >
     600             : typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
     601             : {
     602             :     return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
     603             :                                                                   false));
     604             : }
     605             : 
     606             : template< typename Val >
     607             : bool RegexpMap< Val >::empty() const
     608             : {
     609             :     return !m_pImpl->m_pDefault
     610             :            && m_pImpl->m_aList[Regexp::KIND_PREFIX].empty()
     611             :            && m_pImpl->m_aList[Regexp::KIND_AUTHORITY].empty()
     612             :            && m_pImpl->m_aList[Regexp::KIND_DOMAIN].empty();
     613             : }
     614             : 
     615             : template< typename Val >
     616           0 : typename RegexpMap< Val >::size_type RegexpMap< Val >::size() const
     617             : {
     618             :     return (m_pImpl->m_pDefault ? 1 : 0)
     619           0 :                + m_pImpl->m_aList[Regexp::KIND_PREFIX].size()
     620           0 :                + m_pImpl->m_aList[Regexp::KIND_AUTHORITY].size()
     621           0 :                + m_pImpl->m_aList[Regexp::KIND_DOMAIN].size();
     622             : }
     623             : 
     624             : template< typename Val >
     625           0 : Val const * RegexpMap< Val >::map(rtl::OUString const & rString,
     626             :                                   rtl::OUString * pTranslation,
     627             :                                   bool * pTranslated) const
     628             : {
     629           0 :     for (int n = Regexp::KIND_DOMAIN; n >= Regexp::KIND_PREFIX; --n)
     630             :     {
     631           0 :         List< Val > const & rTheList = m_pImpl->m_aList[n];
     632             : 
     633           0 :         typename List< Val >::const_iterator aEnd(rTheList.end());
     634           0 :         for (typename List< Val >::const_iterator aIt(rTheList.begin()); aIt != aEnd;
     635             :              ++aIt)
     636           0 :             if (aIt->m_aRegexp.matches(rString, pTranslation, pTranslated))
     637           0 :                 return &aIt->m_aValue;
     638             :     }
     639           0 :     if (m_pImpl->m_pDefault
     640           0 :         && m_pImpl->m_pDefault->m_aRegexp.matches(rString, pTranslation,
     641             :                                                   pTranslated))
     642           0 :         return &m_pImpl->m_pDefault->m_aValue;
     643           0 :     return 0;
     644             : }
     645             : 
     646             : }
     647             : 
     648             : 
     649             : template< typename Val >
     650           0 : inline bool operator ==(ucb_impl::RegexpMapConstIter< Val > const & rIter1,
     651             :                         ucb_impl::RegexpMapConstIter< Val > const & rIter2)
     652             : {
     653           0 :     return rIter1.equals(rIter2);
     654             : }
     655             : 
     656             : template< typename Val >
     657           0 : inline bool operator !=(ucb_impl::RegexpMapConstIter< Val > const & rIter1,
     658             :                         ucb_impl::RegexpMapConstIter< Val > const & rIter2)
     659             : {
     660           0 :     return !rIter1.equals(rIter2);
     661             : }
     662             : 
     663             : #endif // _UCB_REGEXPMAP_HXX_
     664             : 
     665             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10