564 lines
15 KiB
Text
564 lines
15 KiB
Text
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
#ifndef _UCB_REGEXPMAP_TPT_
|
|
#define _UCB_REGEXPMAP_TPT_
|
|
|
|
#ifndef _UCB_REGEXPMAP_HXX_
|
|
#include <regexpmap.hxx>
|
|
#endif
|
|
|
|
#include <list>
|
|
|
|
#ifndef _RTL_USTRING_HXX_
|
|
#include <rtl/ustring.hxx>
|
|
#endif
|
|
|
|
#ifndef _UCB_REGEXP_HXX_
|
|
#include "regexp.hxx"
|
|
#endif
|
|
|
|
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);
|
|
|
|
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;
|
|
m_aIndex = typename List< Val >::iterator();
|
|
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 >
|
|
bool RegexpMapIterImpl< Val >::operator ==(RegexpMapIterImpl const & rOther)
|
|
const
|
|
{
|
|
return m_pMap == rOther.m_pMap
|
|
&& m_nList == rOther.m_nList
|
|
&& 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_
|