summaryrefslogtreecommitdiff
path: root/ucb
diff options
context:
space:
mode:
Diffstat (limited to 'ucb')
-rw-r--r--ucb/source/core/ucb.cxx6
-rw-r--r--ucb/source/inc/regexpmap.hxx494
-rw-r--r--ucb/source/inc/regexpmap.tpt579
3 files changed, 488 insertions, 591 deletions
diff --git a/ucb/source/core/ucb.cxx b/ucb/source/core/ucb.cxx
index 324641dc6ce2..493ff514f5ec 100644
--- a/ucb/source/core/ucb.cxx
+++ b/ucb/source/core/ucb.cxx
@@ -44,12 +44,6 @@
#include "ucb.hxx"
-// Definitions for ProviderMap_Impl (Solaris wouldn't find explicit template
-// instantiations for these in another compilation unit...):
-#ifndef _UCB_REGEXPMAP_TPT_
-#include <regexpmap.tpt>
-#endif
-
using namespace cppu;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
diff --git a/ucb/source/inc/regexpmap.hxx b/ucb/source/inc/regexpmap.hxx
index 3e960d1bd93b..dc1f95d85416 100644
--- a/ucb/source/inc/regexpmap.hxx
+++ b/ucb/source/inc/regexpmap.hxx
@@ -20,9 +20,15 @@
#ifndef _UCB_REGEXPMAP_HXX_
#define _UCB_REGEXPMAP_HXX_
+#include "sal/config.h"
+
+#include <list>
+
#include <rtl/ustring.hxx>
#include <sal/types.h>
+#include "regexp.hxx"
+
namespace ucb_impl {
template< typename Val > class RegexpMap;
@@ -49,11 +55,199 @@ private:
};
//============================================================================
-template< typename Val > class RegexpMapIterImpl;
- // MSC doesn't like this to be a private RegexpMapConstIter member
- // class...
template< typename Val >
+struct Entry
+{
+ Regexp m_aRegexp;
+ Val m_aValue;
+
+ inline Entry(Regexp const & rTheRegexp, Val const & rTheValue):
+ m_aRegexp(rTheRegexp), m_aValue(rTheValue) {}
+};
+
+//============================================================================
+template< typename Val > class List: public std::list< Entry< Val > > {};
+
+//============================================================================
+template< typename Val >
+struct RegexpMapImpl
+{
+ List< Val > m_aList[Regexp::KIND_DOMAIN + 1];
+ Entry< Val > * m_pDefault;
+
+ RegexpMapImpl(): m_pDefault(0) {}
+
+ ~RegexpMapImpl() { delete m_pDefault; }
+};
+
+//============================================================================
+template< typename Val >
+class RegexpMapIterImpl
+{
+public:
+ typedef RegexpMapImpl< Val > MapImpl;
+ typedef typename List< Val >::iterator ListIterator;
+
+ // Solaris needs these for the ctor...
+
+ inline RegexpMapIterImpl();
+
+ inline RegexpMapIterImpl(MapImpl * pTheMap, int nTheList,
+ ListIterator aTheIndex);
+
+ RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap, bool bBegin);
+
+ RegexpMapIterImpl(RegexpMapIterImpl const & rOther);
+
+ RegexpMapIterImpl & operator =(RegexpMapIterImpl const & rOther);
+
+ bool operator ==(RegexpMapIterImpl const & rOther) const;
+
+ RegexpMapImpl< Val > const * getMap() const { return m_pMap; }
+
+ int getList() const { return m_nList; }
+
+ typename List< Val >::iterator const & getIndex() const { return m_aIndex; }
+
+ void next();
+
+ RegexpMapEntry< Val > & get();
+
+private:
+ mutable RegexpMapEntry< Val > m_aEntry;
+ typename List< Val >::iterator m_aIndex;
+ RegexpMapImpl< Val > * m_pMap;
+ int m_nList;
+ mutable bool m_bEntrySet;
+
+ void setEntry() const;
+};
+
+template< typename Val >
+inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
+ m_aEntry(rtl::OUString(), 0),
+ m_pMap(0),
+ m_nList(-1),
+ m_bEntrySet(false)
+{}
+
+template< typename Val >
+inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(MapImpl * pTheMap,
+ int nTheList,
+ ListIterator aTheIndex):
+ m_aEntry(rtl::OUString(), 0),
+ m_aIndex(aTheIndex),
+ m_pMap(pTheMap),
+ m_nList(nTheList),
+ m_bEntrySet(false)
+{}
+
+template< typename Val >
+void RegexpMapIterImpl< Val >::setEntry() const
+{
+ if (!m_bEntrySet)
+ {
+ Entry< Val > const & rTheEntry
+ = m_nList == -1 ? *m_pMap->m_pDefault : *m_aIndex;
+ m_aEntry
+ = RegexpMapEntry< Val >(rTheEntry.m_aRegexp.getRegexp(false),
+ const_cast< Val * >(&rTheEntry.m_aValue));
+ m_bEntrySet = true;
+ }
+}
+
+template< typename Val >
+RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap,
+ bool bBegin):
+ m_aEntry(rtl::OUString(), 0),
+ m_pMap(pTheMap),
+ m_bEntrySet(false)
+{
+ if (bBegin)
+ {
+ m_nList = -1;
+ if (!m_pMap->m_pDefault)
+ next();
+ }
+ else
+ {
+ m_nList = Regexp::KIND_DOMAIN;
+ m_aIndex = m_pMap->m_aList[Regexp::KIND_DOMAIN].end();
+ }
+}
+
+template< typename Val >
+RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapIterImpl const & rOther):
+ m_aEntry(rOther.m_aEntry), m_pMap(rOther.m_pMap), m_nList(rOther.m_nList),
+ m_bEntrySet(rOther.m_bEntrySet)
+{
+ if (m_nList != -1)
+ m_aIndex = rOther.m_aIndex;
+}
+
+template< typename Val >
+RegexpMapIterImpl< Val > & RegexpMapIterImpl< Val >::operator =(
+ RegexpMapIterImpl const & rOther)
+{
+ if (this != &rOther)
+ {
+ m_aEntry = rOther.m_aEntry;
+ m_pMap = rOther.m_pMap;
+ m_nList = rOther.m_nList;
+ m_bEntrySet = rOther.m_bEntrySet;
+ if (m_nList == -1)
+ m_aIndex = typename List< Val >::iterator();
+ else
+ m_aIndex = rOther.m_aIndex;
+ }
+ return *this;
+}
+
+template< typename Val >
+bool RegexpMapIterImpl< Val >::operator ==(RegexpMapIterImpl const & rOther)
+ const
+{
+ return m_pMap == rOther.m_pMap
+ && m_nList == rOther.m_nList
+ && (m_nList == -1 || m_aIndex == rOther.m_aIndex);
+}
+
+template< typename Val >
+void RegexpMapIterImpl< Val >::next()
+{
+ switch (m_nList)
+ {
+ case Regexp::KIND_DOMAIN:
+ if (m_aIndex == m_pMap->m_aList[m_nList].end())
+ return;
+ default:
+ ++m_aIndex;
+ if (m_nList == Regexp::KIND_DOMAIN
+ || m_aIndex != m_pMap->m_aList[m_nList].end())
+ break;
+ case -1:
+ do
+ {
+ ++m_nList;
+ m_aIndex = m_pMap->m_aList[m_nList].begin();
+ }
+ while (m_nList < Regexp::KIND_DOMAIN
+ && m_aIndex == m_pMap->m_aList[m_nList].end());
+ break;
+ }
+ m_bEntrySet = false;
+}
+
+template< typename Val >
+RegexpMapEntry< Val > & RegexpMapIterImpl< Val >::get()
+{
+ setEntry();
+ return m_aEntry;
+}
+
+//============================================================================
+template< typename Val >
class RegexpMapConstIter
{
friend class RegexpMap< Val >; // to access m_pImpl, ctor
@@ -85,6 +279,71 @@ private:
RegexpMapConstIter(RegexpMapIterImpl< Val > * pTheImpl);
};
+template< typename Val >
+RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapIterImpl< Val > *
+ pTheImpl):
+ m_pImpl(pTheImpl)
+{}
+
+template< typename Val >
+RegexpMapConstIter< Val >::RegexpMapConstIter():
+ m_pImpl(new RegexpMapIterImpl< Val >)
+{}
+
+template< typename Val >
+RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapConstIter const &
+ rOther):
+ m_pImpl(new RegexpMapIterImpl< Val >(*rOther.m_pImpl))
+{}
+
+template< typename Val >
+RegexpMapConstIter< Val >::~RegexpMapConstIter()
+{
+ delete m_pImpl;
+}
+
+template< typename Val >
+RegexpMapConstIter< Val > &
+RegexpMapConstIter< Val >::operator =(RegexpMapConstIter const & rOther)
+{
+ *m_pImpl = *rOther.m_pImpl;
+ return *this;
+}
+
+template< typename Val >
+RegexpMapConstIter< Val > & RegexpMapConstIter< Val >::operator ++()
+{
+ m_pImpl->next();
+ return *this;
+}
+
+template< typename Val >
+RegexpMapConstIter< Val > RegexpMapConstIter< Val >::operator ++(int)
+{
+ RegexpMapConstIter aTemp(*this);
+ m_pImpl->next();
+ return aTemp;
+}
+
+template< typename Val >
+RegexpMapEntry< Val > const & RegexpMapConstIter< Val >::operator *() const
+{
+ return m_pImpl->get();
+}
+
+template< typename Val >
+RegexpMapEntry< Val > const * RegexpMapConstIter< Val >::operator ->() const
+{
+ return &m_pImpl->get();
+}
+
+template< typename Val >
+bool RegexpMapConstIter< Val >::equals(RegexpMapConstIter const & rOther)
+ const
+{
+ return *m_pImpl == *rOther.m_pImpl;
+}
+
//============================================================================
template< typename Val >
class RegexpMapIter: public RegexpMapConstIter< Val >
@@ -110,11 +369,52 @@ private:
RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl);
};
-//============================================================================
-template< typename Val > struct RegexpMapImpl;
- // MSC doesn't like this to be a RegexpMap member class...
+template< typename Val >
+RegexpMapIter< Val >::RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl):
+ RegexpMapConstIter< Val >(pTheImpl)
+{}
+
+template< typename Val >
+RegexpMapIter< Val > & RegexpMapIter< Val >::operator ++()
+{
+ this->m_pImpl->next();
+ return *this;
+}
+
+template< typename Val >
+RegexpMapIter< Val > RegexpMapIter< Val >::operator ++(int)
+{
+ RegexpMapIter aTemp(*this);
+ this->m_pImpl->next();
+ return aTemp;
+}
template< typename Val >
+RegexpMapEntry< Val > & RegexpMapIter< Val >::operator *()
+{
+ return this->m_pImpl->get();
+}
+
+template< typename Val >
+RegexpMapEntry< Val > const & RegexpMapIter< Val >::operator *() const
+{
+ return this->m_pImpl->get();
+}
+
+template< typename Val >
+RegexpMapEntry< Val > * RegexpMapIter< Val >::operator ->()
+{
+ return &this->m_pImpl->get();
+}
+
+template< typename Val >
+RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
+{
+ return &this->m_pImpl->get();
+}
+
+//============================================================================
+template< typename Val >
class RegexpMap
{
public:
@@ -159,6 +459,188 @@ private:
RegexpMapImpl< Val > * m_pImpl;
};
+template< typename Val >
+RegexpMap< Val >::RegexpMap():
+ m_pImpl(new RegexpMapImpl< Val >)
+{}
+
+template< typename Val >
+RegexpMap< Val >::RegexpMap(RegexpMap const & rOther):
+ m_pImpl(new RegexpMapImpl< Val >(*rOther.m_pImpl))
+{}
+
+template< typename Val >
+RegexpMap< Val >::~RegexpMap()
+{
+ delete m_pImpl;
+}
+
+template< typename Val >
+RegexpMap< Val > & RegexpMap< Val >::operator =(RegexpMap const & rOther)
+{
+ *m_pImpl = *rOther.m_pImpl;
+ return *this;
+}
+
+template< typename Val >
+bool RegexpMap< Val >::add(rtl::OUString const & rKey, Val const & rValue,
+ bool bOverwrite, rtl::OUString * pReverse)
+{
+ Regexp aRegexp(Regexp::parse(rKey));
+
+ if (aRegexp.isDefault())
+ {
+ if (m_pImpl->m_pDefault)
+ {
+ if (!bOverwrite)
+ return false;
+ delete m_pImpl->m_pDefault;
+ }
+ m_pImpl->m_pDefault = new Entry< Val >(aRegexp, rValue);
+ }
+ else
+ {
+ List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
+
+ typename List< Val >::iterator aEnd(rTheList.end());
+ for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
+ {
+ if (aIt->m_aRegexp == aRegexp)
+ {
+ if (bOverwrite)
+ {
+ rTheList.erase(aIt);
+ break;
+ }
+ else
+ return false;
+ }
+ }
+
+ rTheList.push_back(Entry< Val >(aRegexp, rValue));
+ }
+
+ if (pReverse)
+ *pReverse = aRegexp.getRegexp(true);
+
+ return true;
+}
+
+template< typename Val >
+typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const & rKey,
+ rtl::OUString * pReverse)
+{
+ Regexp aRegexp(Regexp::parse(rKey));
+
+ if (pReverse)
+ *pReverse = aRegexp.getRegexp(true);
+
+ if (aRegexp.isDefault())
+ {
+ if (m_pImpl->m_pDefault)
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
+ true));
+ }
+ else
+ {
+ List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
+
+ typename List< Val > ::iterator aEnd(rTheList.end());
+ for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
+ if (aIt->m_aRegexp == aRegexp)
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(
+ m_pImpl,
+ aRegexp.getKind(), aIt));
+ }
+
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
+}
+
+template< typename Val >
+void RegexpMap< Val >::erase(iterator const & rPos)
+{
+ if (rPos.m_pImpl->getMap() == m_pImpl)
+ {
+ if (rPos.m_pImpl->getList() == -1)
+ {
+ if (m_pImpl->m_pDefault)
+ {
+ delete m_pImpl->m_pDefault;
+ m_pImpl->m_pDefault = 0;
+ }
+ }
+ else
+ m_pImpl->m_aList[rPos.m_pImpl->getList()].
+ erase(rPos.m_pImpl->getIndex());
+ }
+}
+
+template< typename Val >
+typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
+{
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, true));
+}
+
+template< typename Val >
+typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
+{
+ return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
+ true));
+}
+
+template< typename Val >
+typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
+{
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
+}
+
+template< typename Val >
+typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
+{
+ return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
+ false));
+}
+
+template< typename Val >
+bool RegexpMap< Val >::empty() const
+{
+ return !m_pImpl->m_pDefault
+ && m_pImpl->m_aList[Regexp::KIND_PREFIX].empty()
+ && m_pImpl->m_aList[Regexp::KIND_AUTHORITY].empty()
+ && m_pImpl->m_aList[Regexp::KIND_DOMAIN].empty();
+}
+
+template< typename Val >
+typename RegexpMap< Val >::size_type RegexpMap< Val >::size() const
+{
+ return (m_pImpl->m_pDefault ? 1 : 0)
+ + m_pImpl->m_aList[Regexp::KIND_PREFIX].size()
+ + m_pImpl->m_aList[Regexp::KIND_AUTHORITY].size()
+ + m_pImpl->m_aList[Regexp::KIND_DOMAIN].size();
+}
+
+template< typename Val >
+Val const * RegexpMap< Val >::map(rtl::OUString const & rString,
+ rtl::OUString * pTranslation,
+ bool * pTranslated) const
+{
+ for (int n = Regexp::KIND_DOMAIN; n >= Regexp::KIND_PREFIX; --n)
+ {
+ List< Val > const & rTheList = m_pImpl->m_aList[n];
+
+ typename List< Val >::const_iterator aEnd(rTheList.end());
+ for (typename List< Val >::const_iterator aIt(rTheList.begin()); aIt != aEnd;
+ ++aIt)
+ if (aIt->m_aRegexp.matches(rString, pTranslation, pTranslated))
+ return &aIt->m_aValue;
+ }
+ if (m_pImpl->m_pDefault
+ && m_pImpl->m_pDefault->m_aRegexp.matches(rString, pTranslation,
+ pTranslated))
+ return &m_pImpl->m_pDefault->m_aValue;
+ return 0;
+}
+
}
//============================================================================
diff --git a/ucb/source/inc/regexpmap.tpt b/ucb/source/inc/regexpmap.tpt
deleted file mode 100644
index a5836e6dc7d7..000000000000
--- a/ucb/source/inc/regexpmap.tpt
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed
- * with this work for additional information regarding copyright
- * ownership. The ASF licenses this file to you under the Apache
- * License, Version 2.0 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#ifndef _UCB_REGEXPMAP_TPT_
-#define _UCB_REGEXPMAP_TPT_
-
-#include <regexpmap.hxx>
-#include <list>
-#include <rtl/ustring.hxx>
-
-#include "regexp.hxx"
-
-using namespace ucb_impl;
-
-namespace ucb_impl {
-
-//============================================================================
-
-template< typename Val >
-struct Entry
-{
- Regexp m_aRegexp;
- Val m_aValue;
-
- inline Entry(Regexp const & rTheRegexp, Val const & rTheValue):
- m_aRegexp(rTheRegexp), m_aValue(rTheValue) {}
-};
-
-//============================================================================
-template< typename Val > class List: public std::list< Entry< Val > > {};
-
-//============================================================================
-//
-// RegexpMapIterImpl
-//
-//============================================================================
-
-template< typename Val >
-class RegexpMapIterImpl
-{
-public:
- typedef RegexpMapImpl< Val > MapImpl;
- typedef typename List< Val >::iterator ListIterator;
-
- // Solaris needs these for the ctor...
-
- inline RegexpMapIterImpl();
-
- inline RegexpMapIterImpl(MapImpl * pTheMap, int nTheList,
- ListIterator aTheIndex);
-
- RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap, bool bBegin);
-
- RegexpMapIterImpl(RegexpMapIterImpl const & rOther);
-
- RegexpMapIterImpl & operator =(RegexpMapIterImpl const & rOther);
-
- bool operator ==(RegexpMapIterImpl const & rOther) const;
-
- RegexpMapImpl< Val > const * getMap() const { return m_pMap; }
-
- int getList() const { return m_nList; }
-
- typename List< Val >::iterator const & getIndex() const { return m_aIndex; }
-
- void next();
-
- RegexpMapEntry< Val > & get();
-
-private:
- mutable RegexpMapEntry< Val > m_aEntry;
- typename List< Val >::iterator m_aIndex;
- RegexpMapImpl< Val > * m_pMap;
- int m_nList;
- mutable bool m_bEntrySet;
-
- void setEntry() const;
-};
-
-}
-
-template< typename Val >
-inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
- m_aEntry(rtl::OUString(), 0),
- m_pMap(0),
- m_nList(-1),
- m_bEntrySet(false)
-{}
-
-template< typename Val >
-inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(MapImpl * pTheMap,
- int nTheList,
- ListIterator aTheIndex):
- m_aEntry(rtl::OUString(), 0),
- m_aIndex(aTheIndex),
- m_pMap(pTheMap),
- m_nList(nTheList),
- m_bEntrySet(false)
-{}
-
-//============================================================================
-template< typename Val >
-void RegexpMapIterImpl< Val >::setEntry() const
-{
- if (!m_bEntrySet)
- {
- Entry< Val > const & rTheEntry
- = m_nList == -1 ? *m_pMap->m_pDefault : *m_aIndex;
- m_aEntry
- = RegexpMapEntry< Val >(rTheEntry.m_aRegexp.getRegexp(false),
- const_cast< Val * >(&rTheEntry.m_aValue));
- m_bEntrySet = true;
- }
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap,
- bool bBegin):
- m_aEntry(rtl::OUString(), 0),
- m_pMap(pTheMap),
- m_bEntrySet(false)
-{
- if (bBegin)
- {
- m_nList = -1;
- if (!m_pMap->m_pDefault)
- next();
- }
- else
- {
- m_nList = Regexp::KIND_DOMAIN;
- m_aIndex = m_pMap->m_aList[Regexp::KIND_DOMAIN].end();
- }
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapIterImpl const & rOther):
- m_aEntry(rOther.m_aEntry), m_pMap(rOther.m_pMap), m_nList(rOther.m_nList),
- m_bEntrySet(rOther.m_bEntrySet)
-{
- if (m_nList != -1)
- m_aIndex = rOther.m_aIndex;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapIterImpl< Val > & RegexpMapIterImpl< Val >::operator =(
- RegexpMapIterImpl const & rOther)
-{
- if (this != &rOther)
- {
- m_aEntry = rOther.m_aEntry;
- m_pMap = rOther.m_pMap;
- m_nList = rOther.m_nList;
- m_bEntrySet = rOther.m_bEntrySet;
- if (m_nList == -1)
- m_aIndex = typename List< Val >::iterator();
- else
- m_aIndex = rOther.m_aIndex;
- }
- return *this;
-}
-
-//============================================================================
-template< typename Val >
-bool RegexpMapIterImpl< Val >::operator ==(RegexpMapIterImpl const & rOther)
- const
-{
- return m_pMap == rOther.m_pMap
- && m_nList == rOther.m_nList
- && (m_nList == -1 || m_aIndex == rOther.m_aIndex);
-}
-
-//============================================================================
-template< typename Val >
-void RegexpMapIterImpl< Val >::next()
-{
- switch (m_nList)
- {
- case Regexp::KIND_DOMAIN:
- if (m_aIndex == m_pMap->m_aList[m_nList].end())
- return;
- default:
- ++m_aIndex;
- if (m_nList == Regexp::KIND_DOMAIN
- || m_aIndex != m_pMap->m_aList[m_nList].end())
- break;
- case -1:
- do
- {
- ++m_nList;
- m_aIndex = m_pMap->m_aList[m_nList].begin();
- }
- while (m_nList < Regexp::KIND_DOMAIN
- && m_aIndex == m_pMap->m_aList[m_nList].end());
- break;
- }
- m_bEntrySet = false;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > & RegexpMapIterImpl< Val >::get()
-{
- setEntry();
- return m_aEntry;
-}
-
-//============================================================================
-//
-// RegexpMapConstIter
-//
-//============================================================================
-
-template< typename Val >
-RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapIterImpl< Val > *
- pTheImpl):
- m_pImpl(pTheImpl)
-{}
-
-//============================================================================
-template< typename Val >
-RegexpMapConstIter< Val >::RegexpMapConstIter():
- m_pImpl(new RegexpMapIterImpl< Val >)
-{}
-
-//============================================================================
-template< typename Val >
-RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapConstIter const &
- rOther):
- m_pImpl(new RegexpMapIterImpl< Val >(*rOther.m_pImpl))
-{}
-
-//============================================================================
-template< typename Val >
-RegexpMapConstIter< Val >::~RegexpMapConstIter()
-{
- delete m_pImpl;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapConstIter< Val > &
-RegexpMapConstIter< Val >::operator =(RegexpMapConstIter const & rOther)
-{
- *m_pImpl = *rOther.m_pImpl;
- return *this;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapConstIter< Val > & RegexpMapConstIter< Val >::operator ++()
-{
- m_pImpl->next();
- return *this;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapConstIter< Val > RegexpMapConstIter< Val >::operator ++(int)
-{
- RegexpMapConstIter aTemp(*this);
- m_pImpl->next();
- return aTemp;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > const & RegexpMapConstIter< Val >::operator *() const
-{
- return m_pImpl->get();
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > const * RegexpMapConstIter< Val >::operator ->() const
-{
- return &m_pImpl->get();
-}
-
-//============================================================================
-template< typename Val >
-bool RegexpMapConstIter< Val >::equals(RegexpMapConstIter const & rOther)
- const
-{
- return *m_pImpl == *rOther.m_pImpl;
-}
-
-//============================================================================
-//
-// RegexpMapIter
-//
-//============================================================================
-
-template< typename Val >
-RegexpMapIter< Val >::RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl):
- RegexpMapConstIter< Val >(pTheImpl)
-{}
-
-//============================================================================
-template< typename Val >
-RegexpMapIter< Val > & RegexpMapIter< Val >::operator ++()
-{
- this->m_pImpl->next();
- return *this;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapIter< Val > RegexpMapIter< Val >::operator ++(int)
-{
- RegexpMapIter aTemp(*this);
- this->m_pImpl->next();
- return aTemp;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > & RegexpMapIter< Val >::operator *()
-{
- return this->m_pImpl->get();
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > const & RegexpMapIter< Val >::operator *() const
-{
- return this->m_pImpl->get();
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > * RegexpMapIter< Val >::operator ->()
-{
- return &this->m_pImpl->get();
-}
-
-//============================================================================
-template< typename Val >
-RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
-{
- return &this->m_pImpl->get();
-}
-
-//============================================================================
-//
-// RegexpMap
-//
-//============================================================================
-
-namespace ucb_impl {
-
-template< typename Val >
-struct RegexpMapImpl
-{
- List< Val > m_aList[Regexp::KIND_DOMAIN + 1];
- Entry< Val > * m_pDefault;
-
- RegexpMapImpl(): m_pDefault(0) {}
-
- ~RegexpMapImpl() { delete m_pDefault; }
-};
-
-}
-
-//============================================================================
-template< typename Val >
-RegexpMap< Val >::RegexpMap():
- m_pImpl(new RegexpMapImpl< Val >)
-{}
-
-//============================================================================
-template< typename Val >
-RegexpMap< Val >::RegexpMap(RegexpMap const & rOther):
- m_pImpl(new RegexpMapImpl< Val >(*rOther.m_pImpl))
-{}
-
-//============================================================================
-template< typename Val >
-RegexpMap< Val >::~RegexpMap()
-{
- delete m_pImpl;
-}
-
-//============================================================================
-template< typename Val >
-RegexpMap< Val > & RegexpMap< Val >::operator =(RegexpMap const & rOther)
-{
- *m_pImpl = *rOther.m_pImpl;
- return *this;
-}
-
-//============================================================================
-template< typename Val >
-bool RegexpMap< Val >::add(rtl::OUString const & rKey, Val const & rValue,
- bool bOverwrite, rtl::OUString * pReverse)
-{
- Regexp aRegexp(Regexp::parse(rKey));
-
- if (aRegexp.isDefault())
- {
- if (m_pImpl->m_pDefault)
- {
- if (!bOverwrite)
- return false;
- delete m_pImpl->m_pDefault;
- }
- m_pImpl->m_pDefault = new Entry< Val >(aRegexp, rValue);
- }
- else
- {
- List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
-
- typename List< Val >::iterator aEnd(rTheList.end());
- for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
- {
- if (aIt->m_aRegexp == aRegexp)
- {
- if (bOverwrite)
- {
- rTheList.erase(aIt);
- break;
- }
- else
- return false;
- }
- }
-
- rTheList.push_back(Entry< Val >(aRegexp, rValue));
- }
-
- if (pReverse)
- *pReverse = aRegexp.getRegexp(true);
-
- return true;
-}
-
-//============================================================================
-template< typename Val >
-typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const & rKey,
- rtl::OUString * pReverse)
-{
- Regexp aRegexp(Regexp::parse(rKey));
-
- if (pReverse)
- *pReverse = aRegexp.getRegexp(true);
-
- if (aRegexp.isDefault())
- {
- if (m_pImpl->m_pDefault)
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
- true));
- }
- else
- {
- List< Val > & rTheList = m_pImpl->m_aList[aRegexp.getKind()];
-
- typename List< Val > ::iterator aEnd(rTheList.end());
- for (typename List< Val >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
- if (aIt->m_aRegexp == aRegexp)
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(
- m_pImpl,
- aRegexp.getKind(), aIt));
- }
-
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
-}
-
-//============================================================================
-template< typename Val >
-void RegexpMap< Val >::erase(iterator const & rPos)
-{
- if (rPos.m_pImpl->getMap() == m_pImpl)
- {
- if (rPos.m_pImpl->getList() == -1)
- {
- if (m_pImpl->m_pDefault)
- {
- delete m_pImpl->m_pDefault;
- m_pImpl->m_pDefault = 0;
- }
- }
- else
- m_pImpl->m_aList[rPos.m_pImpl->getList()].
- erase(rPos.m_pImpl->getIndex());
- }
-}
-
-//============================================================================
-template< typename Val >
-typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
-{
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, true));
-}
-
-//============================================================================
-template< typename Val >
-typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
-{
- return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
- true));
-}
-
-//============================================================================
-template< typename Val >
-typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
-{
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl, false));
-}
-
-//============================================================================
-template< typename Val >
-typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
-{
- return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(m_pImpl,
- false));
-}
-
-//============================================================================
-template< typename Val >
-bool RegexpMap< Val >::empty() const
-{
- return !m_pImpl->m_pDefault
- && m_pImpl->m_aList[Regexp::KIND_PREFIX].empty()
- && m_pImpl->m_aList[Regexp::KIND_AUTHORITY].empty()
- && m_pImpl->m_aList[Regexp::KIND_DOMAIN].empty();
-}
-
-//============================================================================
-template< typename Val >
-typename RegexpMap< Val >::size_type RegexpMap< Val >::size() const
-{
- return (m_pImpl->m_pDefault ? 1 : 0)
- + m_pImpl->m_aList[Regexp::KIND_PREFIX].size()
- + m_pImpl->m_aList[Regexp::KIND_AUTHORITY].size()
- + m_pImpl->m_aList[Regexp::KIND_DOMAIN].size();
-}
-
-//============================================================================
-template< typename Val >
-Val const * RegexpMap< Val >::map(rtl::OUString const & rString,
- rtl::OUString * pTranslation,
- bool * pTranslated) const
-{
- for (int n = Regexp::KIND_DOMAIN; n >= Regexp::KIND_PREFIX; --n)
- {
- List< Val > const & rTheList = m_pImpl->m_aList[n];
-
- typename List< Val >::const_iterator aEnd(rTheList.end());
- for (typename List< Val >::const_iterator aIt(rTheList.begin()); aIt != aEnd;
- ++aIt)
- if (aIt->m_aRegexp.matches(rString, pTranslation, pTranslated))
- return &aIt->m_aValue;
- }
- if (m_pImpl->m_pDefault
- && m_pImpl->m_pDefault->m_aRegexp.matches(rString, pTranslation,
- pTranslated))
- return &m_pImpl->m_pDefault->m_aValue;
- return 0;
-}
-
-#endif // _UCB_REGEXPMAP_TPT_