Convert from tools/table.hxx to std::map in SvxMacroTableDtor

In this case, we also convert from storing pointers to storing
the items directly because SvxMacroTableDtor completely controls
the lifecycle of the SvxMacro objects it contains.

Also add an operator== to SvxMacroTableDtor and remove the out-of-line
implementations of equals from two other places.

2 files changed, 98 insertions, 72 deletions

diff --git a/svl/inc/svl/macitem.hxx b/svl/inc/svl/macitem.hxx
index 7261316ee7dc..95bd7458c4f3 100644
--- a/svl/inc/svl/macitem.hxx
+++ b/svl/inc/svl/macitem.hxx
@@ -35,8 +35,7 @@
 #include <tools/rtti.hxx>
 #include <tools/debug.hxx>
 #include <tools/string.hxx>
-
-#include <tools/table.hxx>
+#include <map>
 
 class SvStream;
 
@@ -114,34 +113,51 @@ inline SvxMacro::SvxMacro( SjJSbxObjectBase* _pFunctionObject, const ::rtl::OUSt
 
 //Macro Table, zerstoert die Pointer im DTor!
 
-DECLARE_TABLE( _SvxMacroTableDtor, SvxMacro* )
+typedef std::map<sal_uInt16, SvxMacro> SvxMacroTable;
 
 #define SVX_MACROTBL_VERSION31  0
 #define SVX_MACROTBL_VERSION40  1
 
 #define SVX_MACROTBL_AKTVERSION SVX_MACROTBL_VERSION40
 
-class SVL_DLLPUBLIC SvxMacroTableDtor : public _SvxMacroTableDtor
+class SVL_DLLPUBLIC SvxMacroTableDtor
 {
+private:
+    SvxMacroTable aSvxMacroTable;
 public:
-    inline SvxMacroTableDtor( const sal_uInt16 nInitSz = 0, const sal_uInt16 nReSz = 1 );
-    inline SvxMacroTableDtor( const SvxMacroTableDtor &rCpy ) : _SvxMacroTableDtor() { *this = rCpy; }
-    inline ~SvxMacroTableDtor() { DelDtor(); }
+    inline SvxMacroTableDtor() {}
+    inline SvxMacroTableDtor( const SvxMacroTableDtor &rCpy ) : aSvxMacroTable(rCpy.aSvxMacroTable) { }
+
     SvxMacroTableDtor& operator=( const SvxMacroTableDtor &rCpy );
+    int operator==( const SvxMacroTableDtor& rOther ) const;
 
     // loescht alle Eintraege
-    void DelDtor();
+    void clear() { aSvxMacroTable.clear(); }
 
     SvStream&   Read( SvStream &, sal_uInt16 nVersion = SVX_MACROTBL_AKTVERSION );
     SvStream&   Write( SvStream & ) const;
 
     sal_uInt16 GetVersion() const       { return SVX_MACROTBL_AKTVERSION; }
+
+    SvxMacroTable::iterator begin() { return aSvxMacroTable.begin(); }
+    SvxMacroTable::const_iterator begin() const { return aSvxMacroTable.begin(); }
+    SvxMacroTable::iterator end() { return aSvxMacroTable.end(); }
+    SvxMacroTable::const_iterator end () const { return aSvxMacroTable.end(); }
+    SvxMacroTable::size_type size() const { return aSvxMacroTable.size(); }
+    bool empty() const { return aSvxMacroTable.empty(); }
+
+    // returns NULL if no entry exists, or a pointer to the internal value
+    const SvxMacro* Get(sal_uInt16 nEvent) const;
+    // returns NULL if no entry exists, or a pointer to the internal value
+    SvxMacro* Get(sal_uInt16 nEvent);
+    // return true if the key exists
+    bool IsKeyValid(sal_uInt16 nEvent) const;
+    // This stores a copy of the rMacro parameter
+    SvxMacro& Insert(sal_uInt16 nEvent, const SvxMacro& rMacro);
+    // If the entry exists, remove it from the map and release it's storage
+    sal_Bool Erase(sal_uInt16 nEvent);
 };
 
-inline SvxMacroTableDtor::SvxMacroTableDtor( const sal_uInt16 nInitSz,
-                                             const sal_uInt16 nReSz)
-    : _SvxMacroTableDtor( nInitSz, nReSz )
-{}
 
 /*
 [Beschreibung]
@@ -200,9 +216,7 @@ inline const SvxMacro& SvxMacroItem::GetMacro( sal_uInt16 nEvent ) const
 }
 inline sal_Bool SvxMacroItem::DelMacro( sal_uInt16 nEvent )
 {
-    SvxMacro *pMacro = aMacroTable.Remove( nEvent );
-    delete pMacro;
-    return ( pMacro != 0 );
+    return aMacroTable.Erase(nEvent);
 }
 
 #endif
diff --git a/svl/source/items/macitem.cxx b/svl/source/items/macitem.cxx
index 44abf8589217..c2c41016a381 100644
--- a/svl/source/items/macitem.cxx
+++ b/svl/source/items/macitem.cxx
@@ -99,20 +99,36 @@ SvxMacro& SvxMacro::operator=( const SvxMacro& rBase )
     return *this;
 }
 
+// -----------------------------------------------------------------------
 
 SvxMacroTableDtor& SvxMacroTableDtor::operator=( const SvxMacroTableDtor& rTbl )
 {
-    DelDtor();
-    SvxMacro* pTmp = ((SvxMacroTableDtor&)rTbl).First();
-    while( pTmp )
-    {
-        SvxMacro *pNew = new SvxMacro( *pTmp );
-        Insert( rTbl.GetCurKey(), pNew );
-        pTmp = ((SvxMacroTableDtor&)rTbl).Next();
-    }
+    aSvxMacroTable.clear();
+    aSvxMacroTable.insert(rTbl.aSvxMacroTable.begin(), rTbl.aSvxMacroTable.end());
     return *this;
 }
 
+int SvxMacroTableDtor::operator==( const SvxMacroTableDtor& rOther ) const
+{
+    // Anzahl unterschiedlich => auf jeden Fall ungleich
+    if ( aSvxMacroTable.size() != rOther.aSvxMacroTable.size() )
+        return sal_False;
+
+    // einzeln verleichen; wegen Performance ist die Reihenfolge wichtig
+    SvxMacroTable::const_iterator it1 = aSvxMacroTable.begin();
+    SvxMacroTable::const_iterator it2 = rOther.aSvxMacroTable.begin();
+    for ( ; it1 != aSvxMacroTable.end(); ++it1, ++it2 )
+    {
+        const SvxMacro& rOwnMac = it1->second;
+        const SvxMacro& rOtherMac = it2->second;
+        if (    it1->first != it2->first ||
+                rOwnMac.GetLibName() != rOtherMac.GetLibName() ||
+                rOwnMac.GetMacName() != rOtherMac.GetMacName() )
+            return sal_False;
+    }
+
+    return sal_True;
+}
 
 SvStream& SvxMacroTableDtor::Read( SvStream& rStrm, sal_uInt16 nVersion )
 {
@@ -132,16 +148,7 @@ SvStream& SvxMacroTableDtor::Read( SvStream& rStrm, sal_uInt16 nVersion )
         if( SVX_MACROTBL_VERSION40 <= nVersion )
             rStrm >> eType;
 
-        SvxMacro* pNew = new SvxMacro( aMacName, aLibName, (ScriptType)eType );
-
-        SvxMacro *pOld = Get( nCurKey );
-        if( pOld )
-        {
-            delete pOld;
-            Replace( nCurKey, pNew );
-        }
-        else
-            Insert( nCurKey, pNew );
+        aSvxMacroTable.insert( SvxMacroTable::value_type(nCurKey, SvxMacro( aMacName, aLibName, (ScriptType)eType ) ));
     }
     return rStrm;
 }
@@ -156,33 +163,60 @@ SvStream& SvxMacroTableDtor::Write( SvStream& rStream ) const
     if( SVX_MACROTBL_VERSION40 <= nVersion )
         rStream << nVersion;
 
-    rStream << (sal_uInt16)Count();
+    rStream << (sal_uInt16)aSvxMacroTable.size();
 
-    SvxMacro* pMac = ((SvxMacroTableDtor*)this)->First();
-    while( pMac && rStream.GetError() == SVSTREAM_OK )
+    SvxMacroTable::const_iterator it = aSvxMacroTable.begin();
+    while( it != aSvxMacroTable.end() && rStream.GetError() == SVSTREAM_OK )
     {
-        rStream << (short)GetCurKey();
-        SfxPoolItem::writeByteString(rStream, pMac->GetLibName());
-        SfxPoolItem::writeByteString(rStream, pMac->GetMacName());
+        const SvxMacro& rMac = it->second;
+        rStream << it->first;
+        SfxPoolItem::writeByteString(rStream, rMac.GetLibName());
+        SfxPoolItem::writeByteString(rStream, rMac.GetMacName());
 
         if( SVX_MACROTBL_VERSION40 <= nVersion )
-            rStream << (sal_uInt16)pMac->GetScriptType();
-        pMac = ((SvxMacroTableDtor*)this)->Next();
+            rStream << (sal_uInt16)rMac.GetScriptType();
+        ++it;
     }
     return rStream;
 }
 
-// -----------------------------------------------------------------------
+// returns NULL if no entry exists, or a pointer to the internal value
+const SvxMacro* SvxMacroTableDtor::Get(sal_uInt16 nEvent) const
+{
+    SvxMacroTable::const_iterator it = aSvxMacroTable.find(nEvent);
+    return it == aSvxMacroTable.end() ? NULL : &(it->second);
+}
+
+// returns NULL if no entry exists, or a pointer to the internal value
+SvxMacro* SvxMacroTableDtor::Get(sal_uInt16 nEvent)
+{
+    SvxMacroTable::iterator it = aSvxMacroTable.find(nEvent);
+    return it == aSvxMacroTable.end() ? NULL : &(it->second);
+}
+
+// return true if the key exists
+bool SvxMacroTableDtor::IsKeyValid(sal_uInt16 nEvent) const
+{
+    SvxMacroTable::const_iterator it = aSvxMacroTable.find(nEvent);
+    return it != aSvxMacroTable.end();
+}
 
-void SvxMacroTableDtor::DelDtor()
+// This stores a copy of the rMacro parameter
+SvxMacro& SvxMacroTableDtor::Insert(sal_uInt16 nEvent, const SvxMacro& rMacro)
 {
-    SvxMacro* pTmp = First();
-    while( pTmp )
+    return aSvxMacroTable.insert( SvxMacroTable::value_type( nEvent, rMacro ) ).first->second;
+}
+
+// If the entry exists, remove it from the map and release it's storage
+sal_Bool SvxMacroTableDtor::Erase(sal_uInt16 nEvent)
+{
+    SvxMacroTable::iterator it = aSvxMacroTable.find(nEvent);
+    if ( it != aSvxMacroTable.end())
     {
-        delete pTmp;
-        pTmp = Next();
+        aSvxMacroTable.erase(it);
+        return sal_True;
     }
-    Clear();
+    return sal_False;
 }
 
 // -----------------------------------------------------------------------
@@ -194,22 +228,7 @@ int SvxMacroItem::operator==( const SfxPoolItem& rAttr ) const
     const SvxMacroTableDtor& rOwn = aMacroTable;
     const SvxMacroTableDtor& rOther = ( (SvxMacroItem&) rAttr ).aMacroTable;
 
-    // Anzahl unterschiedlich => auf jeden Fall ungleich
-    if ( rOwn.Count() != rOther.Count() )
-        return sal_False;
-
-    // einzeln verleichen; wegen Performance ist die Reihenfolge wichtig
-    for ( sal_uInt16 nNo = 0; nNo < rOwn.Count(); ++nNo )
-    {
-        const SvxMacro *pOwnMac = rOwn.GetObject(nNo);
-        const SvxMacro *pOtherMac = rOther.GetObject(nNo);
-        if (    rOwn.GetKey(pOwnMac) != rOther.GetKey(pOtherMac)  ||
-                pOwnMac->GetLibName() != pOtherMac->GetLibName() ||
-                pOwnMac->GetMacName() != pOtherMac->GetMacName() )
-            return sal_False;
-    }
-
-    return sal_True;
+    return rOwn == rOther;
 }
 
 // -----------------------------------------------------------------------
@@ -268,14 +287,7 @@ SfxPoolItem* SvxMacroItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const
 
 void SvxMacroItem::SetMacro( sal_uInt16 nEvent, const SvxMacro& rMacro )
 {
-    SvxMacro *pMacro;
-    if ( 0 != (pMacro=aMacroTable.Get(nEvent)) )
-    {
-        delete pMacro;
-        aMacroTable.Replace(nEvent, new SvxMacro( rMacro ) );
-    }
-    else
-        aMacroTable.Insert(nEvent, new SvxMacro( rMacro ) );
+    aMacroTable.Insert( nEvent, rMacro);
 }
 
 // -----------------------------------------------------------------------