[Libreoffice-commits] core.git: 2 commits - ucb/source
Libreoffice Gerrit user
logerrit at kemper.freedesktop.org
Fri Aug 3 14:30:49 UTC 2018
ucb/source/inc/regexpmap.hxx | 272 ++++++++++++-------------------------------
1 file changed, 79 insertions(+), 193 deletions(-)
New commits:
commit 6b8874e780367427ff748556e8744bfe5c91b08e
Author: Noel Grandin <noel.grandin at collabora.co.uk>
AuthorDate: Fri Aug 3 14:32:57 2018 +0200
Commit: Noel Grandin <noel.grandin at collabora.co.uk>
CommitDate: Fri Aug 3 16:30:37 2018 +0200
inline RegexpMapIterImpl into RegexpMapConstIter
no need for header only classes to have an Impl
Change-Id: I66236e3f9137320cfe39d4312cf7682c1d808815
Reviewed-on: https://gerrit.libreoffice.org/58561
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin at collabora.co.uk>
diff --git a/ucb/source/inc/regexpmap.hxx b/ucb/source/inc/regexpmap.hxx
index 46e32086a898..d1345552b92f 100644
--- a/ucb/source/inc/regexpmap.hxx
+++ b/ucb/source/inc/regexpmap.hxx
@@ -68,36 +68,34 @@ struct Entry
template< typename Val >
-class RegexpMapIterImpl
+class RegexpMapConstIter
{
+ friend class RegexpMap< Val >; // to access m_pImpl, ctor
+ friend class RegexpMapIter< Val >; // to access m_pImpl, ctor
+
public:
- typedef RegexpMap< Val > Map;
typedef typename std::vector< Entry< Val > >::iterator ListIterator;
- // Solaris needs these for the ctor...
+ RegexpMapConstIter();
- inline RegexpMapIterImpl();
+ RegexpMapConstIter(RegexpMap< Val > * pTheMap, bool bBegin);
- inline RegexpMapIterImpl(Map * pTheMap, int nTheList,
+ RegexpMapConstIter(RegexpMap< Val > * pTheMap, int nTheList,
ListIterator aTheIndex);
- RegexpMapIterImpl(RegexpMap< Val > * pTheMap, bool bBegin);
-
- RegexpMapIterImpl(RegexpMapIterImpl const & rOther);
-
- RegexpMapIterImpl & operator =(RegexpMapIterImpl const & rOther);
-
- bool operator ==(RegexpMapIterImpl const & rOther) const;
+ RegexpMapConstIter(RegexpMapConstIter const & rOther);
- RegexpMap< Val > const * getMap() const { return m_pMap; }
+ RegexpMapConstIter & operator =(RegexpMapConstIter const & rOther);
- int getList() const { return m_nList; }
+ RegexpMapConstIter & operator ++();
- typename std::vector< Entry< Val > >::iterator const & getIndex() const { return m_aIndex; }
+ RegexpMapEntry< Val > const * operator ->() const;
- void next();
+ bool equals(RegexpMapConstIter const & rOther) const;
+ // for free operator ==(), operator !=()
- RegexpMapEntry< Val > & get();
+protected:
+ RegexpMapEntry< Val > & get() const;
private:
mutable RegexpMapEntry< Val > m_aEntry;
@@ -108,7 +106,7 @@ private:
};
template< typename Val >
-inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
+RegexpMapConstIter< Val >::RegexpMapConstIter():
m_aEntry(rtl::OUString(), 0),
m_pMap(nullptr),
m_nList(-1),
@@ -116,18 +114,7 @@ inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
{}
template< typename Val >
-inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(Map * 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 >
-RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMap< Val > * pTheMap,
+RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMap< Val > * pTheMap,
bool bBegin):
m_aEntry(rtl::OUString(), 0),
m_pMap(pTheMap),
@@ -137,7 +124,7 @@ RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMap< Val > * pTheMap,
{
m_nList = -1;
if (!m_pMap->m_pDefault)
- next();
+ operator++();
}
else
{
@@ -147,7 +134,19 @@ RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMap< Val > * pTheMap,
}
template< typename Val >
-RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapIterImpl const & rOther):
+inline RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMap< Val > * 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 >
+RegexpMapConstIter< Val >::RegexpMapConstIter(RegexpMapConstIter const &
+ rOther):
m_aEntry(rOther.m_aEntry), m_pMap(rOther.m_pMap), m_nList(rOther.m_nList),
m_bEntrySet(rOther.m_bEntrySet)
{
@@ -156,8 +155,8 @@ RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapIterImpl const & rOther):
}
template< typename Val >
-RegexpMapIterImpl< Val > & RegexpMapIterImpl< Val >::operator =(
- RegexpMapIterImpl const & rOther)
+RegexpMapConstIter< Val > &
+RegexpMapConstIter< Val >::operator =(RegexpMapConstIter const & rOther)
{
if (this != &rOther)
{
@@ -174,22 +173,13 @@ RegexpMapIterImpl< Val > & RegexpMapIterImpl< Val >::operator =(
}
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()
+RegexpMapConstIter< Val > & RegexpMapConstIter< Val >::operator ++()
{
switch (m_nList)
{
case Regexp::KIND_DOMAIN:
if (m_aIndex == m_pMap->m_aList[m_nList].end())
- return;
+ return *this;
SAL_FALLTHROUGH;
default:
++m_aIndex;
@@ -208,10 +198,11 @@ void RegexpMapIterImpl< Val >::next()
break;
}
m_bEntrySet = false;
+ return *this;
}
template< typename Val >
-RegexpMapEntry< Val > & RegexpMapIterImpl< Val >::get()
+RegexpMapEntry< Val > & RegexpMapConstIter< Val >::get() const
{
if (!m_bEntrySet)
{
@@ -225,84 +216,19 @@ RegexpMapEntry< Val > & RegexpMapIterImpl< Val >::get()
return m_aEntry;
}
-
-template< typename Val >
-class RegexpMapConstIter
-{
- friend class RegexpMap< Val >; // to access m_pImpl, ctor
- friend class RegexpMapIter< Val >; // to access m_pImpl, ctor
-
-public:
- RegexpMapConstIter();
-
- RegexpMapConstIter(RegexpMapConstIter const & rOther);
-
- ~RegexpMapConstIter();
-
- RegexpMapConstIter & operator =(RegexpMapConstIter const & rOther);
-
- RegexpMapConstIter & operator ++();
-
- RegexpMapEntry< Val > const * operator ->() const;
-
- bool equals(RegexpMapConstIter const & rOther) const;
- // for free operator ==(), operator !=()
-
-private:
- RegexpMapIterImpl< Val > * m_pImpl;
-
- 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 >
RegexpMapEntry< Val > const * RegexpMapConstIter< Val >::operator ->() const
{
- return &m_pImpl->get();
+ return &get();
}
template< typename Val >
bool RegexpMapConstIter< Val >::equals(RegexpMapConstIter const & rOther)
const
{
- return *m_pImpl == *rOther.m_pImpl;
+ return m_pMap == rOther.m_pMap
+ && m_nList == rOther.m_nList
+ && (m_nList == -1 || m_aIndex == rOther.m_aIndex);
}
@@ -314,36 +240,36 @@ class RegexpMapIter: public RegexpMapConstIter< Val >
public:
RegexpMapIter() {}
+ RegexpMapIter(RegexpMap< Val > * pTheMap, bool bBegin):
+ RegexpMapConstIter<Val>(pTheMap, bBegin)
+ {}
+
+ RegexpMapIter(RegexpMap< Val > * pTheMap, int nTheList, typename RegexpMapConstIter< Val >::ListIterator aTheIndex):
+ RegexpMapConstIter<Val>(pTheMap, nTheList, aTheIndex)
+ {}
+
RegexpMapEntry< Val > * operator ->();
RegexpMapEntry< Val > const * operator ->() const;
-
-private:
- RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl);
};
template< typename Val >
-RegexpMapIter< Val >::RegexpMapIter(RegexpMapIterImpl< Val > * pTheImpl):
- RegexpMapConstIter< Val >(pTheImpl)
-{}
-
-template< typename Val >
RegexpMapEntry< Val > * RegexpMapIter< Val >::operator ->()
{
- return &this->m_pImpl->get();
+ return &RegexpMapConstIter<Val>::get();
}
template< typename Val >
RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
{
- return &this->m_pImpl->get();
+ return &RegexpMapConstIter<Val>::get();
}
template< typename Val >
class RegexpMap
{
-friend class RegexpMapIterImpl<Val>;
+friend class RegexpMapConstIter<Val>;
public:
typedef sal_uInt32 size_type;
typedef RegexpMapIter< Val > iterator;
@@ -409,8 +335,7 @@ typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const &
if (aRegexp.isDefault())
{
if (m_pDefault)
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this,
- true));
+ return RegexpMapIter< Val >(this, true);
}
else
{
@@ -419,54 +344,49 @@ typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const &
typename std::vector< Entry<Val> >::iterator aEnd(rTheList.end());
for (typename std::vector< Entry<Val> >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
if (aIt->m_aRegexp == aRegexp)
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(
- this,
- aRegexp.getKind(), aIt));
+ return RegexpMapIter< Val >(this, aRegexp.getKind(), aIt);
}
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this, false));
+ return RegexpMapIter< Val >(this, false);
}
template< typename Val >
void RegexpMap< Val >::erase(iterator const & rPos)
{
- assert(rPos.m_pImpl->getMap() == this);
- if (rPos.m_pImpl->getMap() == this)
+ assert(rPos.m_pMap == this);
+ if (rPos.m_pMap == this)
{
- if (rPos.m_pImpl->getList() == -1)
+ if (rPos.m_nList == -1)
{
m_pDefault.reset();
}
else
- m_aList[rPos.m_pImpl->getList()].
- erase(rPos.m_pImpl->getIndex());
+ m_aList[rPos.m_nList].erase(rPos.m_aIndex);
}
}
template< typename Val >
typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
{
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this, true));
+ return RegexpMapIter< Val >(this, true);
}
template< typename Val >
typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
{
- return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(this,
- true));
+ return RegexpMapConstIter< Val >(this, true);
}
template< typename Val >
typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
{
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this, false));
+ return RegexpMapIter< Val >(this, false);
}
template< typename Val >
typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
{
- return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(this,
- false));
+ return RegexpMapConstIter< Val >(this, false);
}
template< typename Val >
commit 95f21c30a3b5b4436a5cc95c60ca7af6429a8b98
Author: Noel Grandin <noel.grandin at collabora.co.uk>
AuthorDate: Fri Aug 3 14:10:26 2018 +0200
Commit: Noel Grandin <noel.grandin at collabora.co.uk>
CommitDate: Fri Aug 3 16:30:25 2018 +0200
inline RegexpMapImpl into RegexpMap
no need for header-only classes to have Impl's
Change-Id: I65b7f84ebd9eec67ad8be694b7752da59af39a9d
Reviewed-on: https://gerrit.libreoffice.org/58560
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin at collabora.co.uk>
diff --git a/ucb/source/inc/regexpmap.hxx b/ucb/source/inc/regexpmap.hxx
index 665c6aa4f29f..46e32086a898 100644
--- a/ucb/source/inc/regexpmap.hxx
+++ b/ucb/source/inc/regexpmap.hxx
@@ -68,28 +68,20 @@ struct Entry
template< typename Val >
-struct RegexpMapImpl
-{
- std::vector< Entry<Val> > m_aList[Regexp::KIND_DOMAIN + 1];
- std::unique_ptr<Entry< Val >> m_pDefault;
-};
-
-
-template< typename Val >
class RegexpMapIterImpl
{
public:
- typedef RegexpMapImpl< Val > MapImpl;
+ typedef RegexpMap< Val > Map;
typedef typename std::vector< Entry< Val > >::iterator ListIterator;
// Solaris needs these for the ctor...
inline RegexpMapIterImpl();
- inline RegexpMapIterImpl(MapImpl * pTheMap, int nTheList,
+ inline RegexpMapIterImpl(Map * pTheMap, int nTheList,
ListIterator aTheIndex);
- RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap, bool bBegin);
+ RegexpMapIterImpl(RegexpMap< Val > * pTheMap, bool bBegin);
RegexpMapIterImpl(RegexpMapIterImpl const & rOther);
@@ -97,7 +89,7 @@ public:
bool operator ==(RegexpMapIterImpl const & rOther) const;
- RegexpMapImpl< Val > const * getMap() const { return m_pMap; }
+ RegexpMap< Val > const * getMap() const { return m_pMap; }
int getList() const { return m_nList; }
@@ -110,7 +102,7 @@ public:
private:
mutable RegexpMapEntry< Val > m_aEntry;
typename std::vector< Entry< Val > >::iterator m_aIndex;
- RegexpMapImpl< Val > * m_pMap;
+ RegexpMap< Val > * m_pMap;
int m_nList;
mutable bool m_bEntrySet;
};
@@ -124,7 +116,7 @@ inline RegexpMapIterImpl< Val >::RegexpMapIterImpl():
{}
template< typename Val >
-inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(MapImpl * pTheMap,
+inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(Map * pTheMap,
int nTheList,
ListIterator aTheIndex):
m_aEntry(rtl::OUString(), 0),
@@ -135,7 +127,7 @@ inline RegexpMapIterImpl< Val >::RegexpMapIterImpl(MapImpl * pTheMap,
{}
template< typename Val >
-RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMapImpl< Val > * pTheMap,
+RegexpMapIterImpl< Val >::RegexpMapIterImpl(RegexpMap< Val > * pTheMap,
bool bBegin):
m_aEntry(rtl::OUString(), 0),
m_pMap(pTheMap),
@@ -351,19 +343,12 @@ RegexpMapEntry< Val > const * RegexpMapIter< Val >::operator ->() const
template< typename Val >
class RegexpMap
{
+friend class RegexpMapIterImpl<Val>;
public:
typedef sal_uInt32 size_type;
typedef RegexpMapIter< Val > iterator;
typedef RegexpMapConstIter< Val > const_iterator;
- RegexpMap();
-
- RegexpMap(RegexpMap const & rOther);
-
- ~RegexpMap();
-
- RegexpMap & operator =(RegexpMap const & rOther);
-
void add(OUString const & rKey, Val const & rValue);
iterator find(OUString const & rKey);
@@ -383,46 +368,26 @@ public:
Val const * map(OUString const & rString) const;
private:
- RegexpMapImpl< Val > m_aImpl;
+ std::vector< Entry<Val> > m_aList[Regexp::KIND_DOMAIN + 1];
+ std::unique_ptr<Entry< Val >> m_pDefault;
};
template< typename Val >
-RegexpMap< Val >::RegexpMap()
-{}
-
-template< typename Val >
-RegexpMap< Val >::RegexpMap(RegexpMap const & rOther):
- m_aImpl(rOther.m_pImpl)
-{}
-
-template< typename Val >
-RegexpMap< Val >::~RegexpMap()
-{
-}
-
-template< typename Val >
-RegexpMap< Val > & RegexpMap< Val >::operator =(RegexpMap const & rOther)
-{
- m_aImpl = rOther.m_aImpl;
- return *this;
-}
-
-template< typename Val >
void RegexpMap< Val >::add(rtl::OUString const & rKey, Val const & rValue)
{
Regexp aRegexp(Regexp::parse(rKey));
if (aRegexp.isDefault())
{
- if (m_aImpl.m_pDefault)
+ if (m_pDefault)
{
return;
}
- m_aImpl.m_pDefault.reset( new Entry< Val >(aRegexp, rValue) );
+ m_pDefault.reset( new Entry< Val >(aRegexp, rValue) );
}
else
{
- std::vector< Entry<Val> > & rTheList = m_aImpl.m_aList[aRegexp.getKind()];
+ std::vector< Entry<Val> > & rTheList = m_aList[aRegexp.getKind()];
for (auto const& elem : rTheList)
{
@@ -443,36 +408,37 @@ typename RegexpMap< Val >::iterator RegexpMap< Val >::find(rtl::OUString const &
if (aRegexp.isDefault())
{
- if (m_aImpl.m_pDefault)
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(&m_aImpl,
+ if (m_pDefault)
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this,
true));
}
else
{
- std::vector< Entry<Val> > & rTheList = m_aImpl.m_aList[aRegexp.getKind()];
+ std::vector< Entry<Val> > & rTheList = m_aList[aRegexp.getKind()];
typename std::vector< Entry<Val> >::iterator aEnd(rTheList.end());
for (typename std::vector< Entry<Val> >::iterator aIt(rTheList.begin()); aIt != aEnd; ++aIt)
if (aIt->m_aRegexp == aRegexp)
return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(
- &m_aImpl,
+ this,
aRegexp.getKind(), aIt));
}
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(&m_aImpl, false));
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this, false));
}
template< typename Val >
void RegexpMap< Val >::erase(iterator const & rPos)
{
- if (rPos.m_pImpl->getMap() == &m_aImpl)
+ assert(rPos.m_pImpl->getMap() == this);
+ if (rPos.m_pImpl->getMap() == this)
{
if (rPos.m_pImpl->getList() == -1)
{
- m_aImpl.m_pDefault.reset();
+ m_pDefault.reset();
}
else
- m_aImpl.m_aList[rPos.m_pImpl->getList()].
+ m_aList[rPos.m_pImpl->getList()].
erase(rPos.m_pImpl->getIndex());
}
}
@@ -480,36 +446,36 @@ void RegexpMap< Val >::erase(iterator const & rPos)
template< typename Val >
typename RegexpMap< Val >::iterator RegexpMap< Val >::begin()
{
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(&m_aImpl, true));
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this, true));
}
template< typename Val >
typename RegexpMap< Val >::const_iterator RegexpMap< Val >::begin() const
{
- return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(&m_aImpl,
+ return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(this,
true));
}
template< typename Val >
typename RegexpMap< Val >::iterator RegexpMap< Val >::end()
{
- return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(&m_aImpl, false));
+ return RegexpMapIter< Val >(new RegexpMapIterImpl< Val >(this, false));
}
template< typename Val >
typename RegexpMap< Val >::const_iterator RegexpMap< Val >::end() const
{
- return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(&m_aImpl,
+ return RegexpMapConstIter< Val >(new RegexpMapIterImpl< Val >(this,
false));
}
template< typename Val >
typename RegexpMap< Val >::size_type RegexpMap< Val >::size() const
{
- return (m_aImpl.m_pDefault ? 1 : 0)
- + m_aImpl.m_aList[Regexp::KIND_PREFIX].size()
- + m_aImpl.m_aList[Regexp::KIND_AUTHORITY].size()
- + m_aImpl.m_aList[Regexp::KIND_DOMAIN].size();
+ return (m_pDefault ? 1 : 0)
+ + m_aList[Regexp::KIND_PREFIX].size()
+ + m_aList[Regexp::KIND_AUTHORITY].size()
+ + m_aList[Regexp::KIND_DOMAIN].size();
}
template< typename Val >
@@ -517,15 +483,15 @@ Val const * RegexpMap< Val >::map(rtl::OUString const & rString) const
{
for (int n = Regexp::KIND_DOMAIN; n >= Regexp::KIND_PREFIX; --n)
{
- std::vector< Entry<Val> > const & rTheList = m_aImpl.m_aList[n];
+ std::vector< Entry<Val> > const & rTheList = m_aList[n];
for (auto const & rItem : rTheList)
if (rItem.m_aRegexp.matches(rString))
return &rItem.m_aValue;
}
- if (m_aImpl.m_pDefault
- && m_aImpl.m_pDefault->m_aRegexp.matches(rString))
- return &m_aImpl.m_pDefault->m_aValue;
+ if (m_pDefault
+ && m_pDefault->m_aRegexp.matches(rString))
+ return &m_pDefault->m_aValue;
return 0;
}
More information about the Libreoffice-commits
mailing list