Simplified comphelper::OSequenceIterator and its uses.

comphelper/inc/comphelper/sequence.hxx

@@ -131,16 +131,10 @@ namespace comphelper
     //=====================================================================
     //= iterating through sequences
     //=====================================================================
-    class SAL_NO_VTABLE IIterator
-    {
-    public:
-        virtual sal_Bool hasMoreElements() const = 0;
-        virtual ::com::sun::star::uno::Any  nextElement() = 0;
-    };
     /** a helper class for iterating through a sequence
     */
     template <class TYPE>
-    class OSequenceIterator : public IIterator
+    class OSequenceIterator
     {
         const TYPE* m_pElements;
         sal_Int32   m_nLen;
@@ -154,10 +148,10 @@ namespace comphelper
         */
         OSequenceIterator(const ::com::sun::star::uno::Any& _rSequenceAny);
 
-        virtual sal_Bool hasMoreElements() const;
-        virtual ::com::sun::star::uno::Any  nextElement();
+        sal_Bool hasMoreElements() const;
+        ::com::sun::star::uno::Any  nextElement();
 
-    protected:
+    private:
         void construct(const ::com::sun::star::uno::Sequence< TYPE >& _rSeq);
     };
 

dbaccess/source/filter/xml/xmlExport.cxx

@@ -672,6 +672,19 @@ void ODBExport::exportConnectionData()
     exportLogin();
 }
 // -----------------------------------------------------------------------------
+template< typename T > void ODBExport::exportDataSourceSettingsSequence(
+    ::std::vector< TypedPropertyValue >::iterator const & in)
+{
+    OSequenceIterator< T > i( in->Value );
+    ::rtl::OUString sCurrent;
+    while (i.hasMoreElements())
+    {
+        SvXMLElementExport aDataValue(*this,XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_VALUE, sal_True, sal_False);
+        // (no whitespace inside the tag)
+        Characters(implConvertAny(i.nextElement()));
+    }
+}
+
 void ODBExport::exportDataSourceSettings()
 {
     if ( m_aDataSourceSettings.empty() )
@@ -715,46 +728,34 @@ void ODBExport::exportDataSourceSettings()
         else
         {
             // the not-that-simple case, we need to iterate through the sequence elements
-            SAL_WNODEPRECATED_DECLARATIONS_PUSH
-            ::std::auto_ptr<IIterator> pSequenceIterator;
-            SAL_WNODEPRECATED_DECLARATIONS_POP
             switch (aSimpleType.getTypeClass())
             {
                 case TypeClass_STRING:
-                    pSequenceIterator.reset( new OSequenceIterator< ::rtl::OUString >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< ::rtl::OUString >(
+                        aIter );
                     break;
                 case TypeClass_DOUBLE:
-                    pSequenceIterator.reset( new OSequenceIterator< double >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< double >( aIter );
                     break;
                 case TypeClass_BOOLEAN:
-                    pSequenceIterator.reset( new OSequenceIterator< sal_Bool >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< sal_Bool >( aIter );
                     break;
                 case TypeClass_BYTE:
-                    pSequenceIterator.reset( new OSequenceIterator< sal_Int8 >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< sal_Int8 >( aIter );
                     break;
                 case TypeClass_SHORT:
-                    pSequenceIterator.reset( new OSequenceIterator< sal_Int16 >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< sal_Int16 >( aIter );
                     break;
                 case TypeClass_LONG:
-                    pSequenceIterator.reset( new OSequenceIterator< sal_Int32 >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< sal_Int32 >( aIter );
                     break;
                 case TypeClass_ANY:
-                    pSequenceIterator.reset( new OSequenceIterator< Any >( aIter->Value ) );
+                    exportDataSourceSettingsSequence< Any >( aIter );
                     break;
                 default:
                     OSL_FAIL("unsupported sequence type !");
                     break;
             }
-            if ( pSequenceIterator.get() )
-            {
-                ::rtl::OUString sCurrent;
-                while (pSequenceIterator->hasMoreElements())
-                {
-                    SvXMLElementExport aDataValue(*this,XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_VALUE, sal_True, sal_False);
-                    // (no whitespace inside the tag)
-                    Characters(implConvertAny(pSequenceIterator->nextElement()));
-                }
-            }
         }
     }
 }

dbaccess/source/filter/xml/xmlExport.hxx

@@ -137,6 +137,8 @@ class ODBExport : public SvXMLExport
     void                    exportDelimiter();
     void                    exportAutoIncrement();
     void                    exportCharSet();
+    template< typename T > void exportDataSourceSettingsSequence(
+        ::std::vector< TypedPropertyValue >::iterator const & in);
     void                    exportDataSourceSettings();
     void                    exportForms();
     void                    exportReports();

xmloff/source/forms/propertyexport.cxx

@@ -101,7 +101,21 @@ namespace xmloff
         return ( !bIsDefaultValue || bIsDynamicProperty );
     }
 
-    //---------------------------------------------------------------------
+    template< typename T > void
+    OPropertyExport::exportRemainingPropertiesSequence(
+        Any const & value, token::XMLTokenEnum eValueAttName)
+    {
+        OSequenceIterator< T > i(value);
+        while (i.hasMoreElements())
+        {
+            ::rtl::OUString sValue(implConvertAny(i.nextElement()));
+            AddAttribute(XML_NAMESPACE_OFFICE, eValueAttName, sValue );
+            SvXMLElementExport aValueTag(
+                m_rContext.getGlobalContext(), XML_NAMESPACE_FORM,
+                token::XML_LIST_VALUE, sal_True, sal_False);
+        }
+    }
+
     void OPropertyExport::exportRemainingProperties()
     {
         // the properties tag (will be created if we have at least one no-default property)
@@ -189,49 +203,40 @@ namespace xmloff
                     continue;
 
                 // the not-that-simple case, we need to iterate through the sequence elements
-                IIterator* pSequenceIterator = NULL;
-
                 switch ( aExportType.getTypeClass() )
                 {
                     case TypeClass_STRING:
-                        pSequenceIterator = new OSequenceIterator< ::rtl::OUString >(aValue);
+                        exportRemainingPropertiesSequence< ::rtl::OUString >(
+                            aValue, eValueAttName);
                         break;
                     case TypeClass_DOUBLE:
-                        pSequenceIterator = new OSequenceIterator< double >(aValue);
+                        exportRemainingPropertiesSequence< double >(
+                            aValue, eValueAttName);
                         break;
                     case TypeClass_BOOLEAN:
-                        pSequenceIterator = new OSequenceIterator< sal_Bool >(aValue);
+                        exportRemainingPropertiesSequence< sal_Bool >(
+                            aValue, eValueAttName);
                         break;
                     case TypeClass_BYTE:
-                        pSequenceIterator = new OSequenceIterator< sal_Int8 >(aValue);
+                        exportRemainingPropertiesSequence< sal_Int8 >(
+                            aValue, eValueAttName);
                         break;
                     case TypeClass_SHORT:
-                        pSequenceIterator = new OSequenceIterator< sal_Int16 >(aValue);
+                        exportRemainingPropertiesSequence< sal_Int16 >(
+                            aValue, eValueAttName);
                         break;
                     case TypeClass_LONG:
-                        pSequenceIterator = new OSequenceIterator< sal_Int32 >(aValue);
+                        exportRemainingPropertiesSequence< sal_Int32 >(
+                            aValue, eValueAttName);
                         break;
                     case TypeClass_HYPER:
-                        pSequenceIterator = new OSequenceIterator< sal_Int64 >(aValue);
+                        exportRemainingPropertiesSequence< sal_Int64 >(
+                            aValue, eValueAttName);
                         break;
                     default:
                         OSL_FAIL("OPropertyExport::exportRemainingProperties: unsupported sequence tyoe !");
                         break;
                 }
-                if (pSequenceIterator)
-                {
-                    while (pSequenceIterator->hasMoreElements())
-                    {
-                        sValue =
-                            implConvertAny(pSequenceIterator->nextElement());
-                        AddAttribute(XML_NAMESPACE_OFFICE, eValueAttName, sValue );
-                        SvXMLElementExport aValueTag(
-                                m_rContext.getGlobalContext(),
-                                XML_NAMESPACE_FORM, token::XML_LIST_VALUE,
-                                sal_True, sal_False);
-                    }
-                }
-                delete pSequenceIterator;
             }
         }
         catch(...)

xmloff/source/forms/propertyexport.hxx

@@ -105,8 +105,10 @@ namespace xmloff
         */
         void examinePersistence();
 
-        /**
-        */
+        template< typename T > void exportRemainingPropertiesSequence(
+            com::sun::star::uno::Any const & value,
+            token::XMLTokenEnum eValueAttName);
+
         void exportRemainingProperties();
 
         /** indicates that a property has been handled by a derived class, without using the helper methods of this