    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * 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 .
     */

    #include <memory>
    #include <com/sun/star/container/XNameContainer.hpp>
    #include <com/sun/star/xml/AttributeData.hpp>
    #include <com/sun/star/beans/XPropertyState.hpp>
    #include <com/sun/star/beans/XMultiPropertySet.hpp>
    #include <com/sun/star/beans/XTolerantMultiPropertySet.hpp>
    #include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
    #include <rtl/ustrbuf.hxx>
    #include <cppuhelper/weakref.hxx>
    #include <list>
    #include <map>

    #include <xmloff/xmlexppr.hxx>
    #include <xmloff/xmltoken.hxx>
    #include <xmloff/attrlist.hxx>
    #include <xmloff/nmspmap.hxx>
    #include <xmloff/xmlnmspe.hxx>
    #include <xmloff/xmlexp.hxx>
    #include <xmloff/xmlprmap.hxx>
    #include <xmloff/maptype.hxx>
    #include <xmloff/xmltypes.hxx>
    #include <xmloff/xmlprhdl.hxx>

    using namespace ::std;
    using namespace ::com::sun::star;
    using namespace ::com::sun::star::beans;
    using namespace ::com::sun::star::uno;
    using namespace ::com::sun::star::lang;
    using namespace ::xmloff::token;

    #define GET_PROP_TYPE( f ) static_cast<sal_uInt16>((f & XML_TYPE_PROP_MASK) >> XML_TYPE_PROP_SHIFT)
    #define ENTRY(t) { GET_PROP_TYPE(XML_TYPE_PROP_##t), XML_##t##_PROPERTIES }

    namespace {

    struct XMLPropTokens_Impl
    {
        sal_uInt16 nType;
        XMLTokenEnum eToken;
    };

    const sal_uInt16 MAX_PROP_TYPES =
        (XML_TYPE_PROP_END >> XML_TYPE_PROP_SHIFT) -
        (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT);

    XMLPropTokens_Impl aPropTokens[MAX_PROP_TYPES] =
    {
        ENTRY(CHART),
        ENTRY(GRAPHIC),
        ENTRY(TABLE),
        ENTRY(TABLE_COLUMN),
        ENTRY(TABLE_ROW),
        ENTRY(TABLE_CELL),
        ENTRY(LIST_LEVEL),
        ENTRY(PARAGRAPH),
        ENTRY(TEXT),
        ENTRY(DRAWING_PAGE),
        ENTRY(PAGE_LAYOUT),
        ENTRY(HEADER_FOOTER),
        ENTRY(RUBY),
        ENTRY(SECTION)
    };

    // public methods

    // Take all properties of the XPropertySet which are also found in the
    // XMLPropertyMapEntry-array and which are not set to their default-value,
    // if a state is available.
    // After that I call the method 'ContextFilter'.

    typedef std::list<XMLPropertyState> XMLPropertyStateList_Impl;

    class XMLPropertyStates_Impl
    {
        XMLPropertyStateList_Impl           aPropStates;
        XMLPropertyStateList_Impl::iterator aLastItr;
        sal_uInt32                          nCount;
    public:
        XMLPropertyStates_Impl();
        void AddPropertyState(const XMLPropertyState& rPropState);
        void FillPropertyStateVector(std::vector<XMLPropertyState>& rVector);
    };

    XMLPropertyStates_Impl::XMLPropertyStates_Impl() :
        aPropStates(),
        nCount(0)
    {
        aLastItr = aPropStates.begin();
    }

    void XMLPropertyStates_Impl::AddPropertyState(
            const XMLPropertyState& rPropState)
    {
        XMLPropertyStateList_Impl::iterator aItr = aPropStates.begin();
        bool bInserted(false);
        if (nCount)
        {
            if (aLastItr->mnIndex < rPropState.mnIndex)
                aItr = ++aLastItr;
        }
        do
        {
            // TODO: one path required only
            if (aItr == aPropStates.end())
            {
                aLastItr = aPropStates.insert(aPropStates.end(), rPropState);
                bInserted = true;
                nCount++;
            }
            else if (aItr->mnIndex > rPropState.mnIndex)
            {
                aLastItr = aPropStates.insert(aItr, rPropState);
                bInserted = true;
                nCount++;
            }
        }
        while(!bInserted && (aItr++ != aPropStates.end()));
    }

    void XMLPropertyStates_Impl::FillPropertyStateVector(
            std::vector<XMLPropertyState>& rVector)
    {
        if (nCount)
        {
            rVector.resize(nCount, XMLPropertyState(-1));
            ::std::copy( aPropStates.begin(), aPropStates.end(), rVector.begin() );
        }
    }

    class FilterPropertyInfo_Impl
    {
        const OUString     sApiName;
        std::list<sal_uInt32>   aIndexes;

    public:

        FilterPropertyInfo_Impl( const OUString& rApiName,
                                 const sal_uInt32 nIndex);

        const OUString& GetApiName() const { return sApiName; }
        std::list<sal_uInt32>& GetIndexes() { return aIndexes; }

        // for sort
        bool operator< ( const FilterPropertyInfo_Impl& rArg ) const
        {
            return (GetApiName() < rArg.GetApiName());
        }
    };

    FilterPropertyInfo_Impl::FilterPropertyInfo_Impl(
            const OUString& rApiName,
            const sal_uInt32 nIndex ) :
        sApiName( rApiName )
    {
        aIndexes.push_back(nIndex);
    }

    typedef std::list<FilterPropertyInfo_Impl> FilterPropertyInfoList_Impl;

    class FilterPropertiesInfo_Impl
    {
        sal_uInt32                              nCount;
        FilterPropertyInfoList_Impl             aPropInfos;

        std::unique_ptr<Sequence<OUString>>     pApiNames;

    public:
        FilterPropertiesInfo_Impl();

        void AddProperty(const OUString& rApiName, const sal_uInt32 nIndex);
        const uno::Sequence<OUString>& GetApiNames();
        void FillPropertyStateArray(
                vector< XMLPropertyState >& rPropStates,
                const Reference< XPropertySet >& xPropSet,
                const rtl::Reference< XMLPropertySetMapper >& maPropMapper,
                const bool bDefault);
        sal_uInt32 GetPropertyCount() const { return nCount; }
    };

    FilterPropertiesInfo_Impl::FilterPropertiesInfo_Impl() :
        nCount(0),
        aPropInfos()
    {
    }

    void FilterPropertiesInfo_Impl::AddProperty(
            const OUString& rApiName, const sal_uInt32 nIndex)
    {
        aPropInfos.emplace_back(rApiName, nIndex);
        nCount++;

        OSL_ENSURE( !pApiNames, "performance warning: API names already retrieved" );
        pApiNames.reset();
    }

    const uno::Sequence<OUString>& FilterPropertiesInfo_Impl::GetApiNames()
    {
        OSL_ENSURE(nCount == aPropInfos.size(), "wrong property count");
        if( !pApiNames )
        {
            // we have to do three things:
            // 1) sort API names,
            // 2) merge duplicates,
            // 3) construct sequence

            // sort names
            aPropInfos.sort();

            // merge duplicates
            if ( nCount > 1 )
            {
                FilterPropertyInfoList_Impl::iterator aOld = aPropInfos.begin();
                FilterPropertyInfoList_Impl::iterator aEnd = aPropInfos.end();
                FilterPropertyInfoList_Impl::iterator aCurrent = aOld;
                ++aCurrent;

                while ( aCurrent != aEnd )
                {
                    // equal to next element?
                    if ( aOld->GetApiName() == aCurrent->GetApiName() )
                    {
                        // if equal: merge index lists
                        aOld->GetIndexes().merge( aCurrent->GetIndexes() );
                        // erase element, and continue with next
                        aCurrent = aPropInfos.erase( aCurrent );
                        nCount--;
                    }
                    else
                    {
                        // remember old element and continue with next
                        aOld = aCurrent;
                        ++aCurrent;
                    }
                }
            }

            // construct sequence
            pApiNames.reset( new Sequence < OUString >( nCount ) );
            OUString *pNames = pApiNames->getArray();

            for (auto const& propInfo : aPropInfos)
            {
                *pNames = propInfo.GetApiName();
                ++pNames;
            }
        }

        return *pApiNames;
    }

    void FilterPropertiesInfo_Impl::FillPropertyStateArray(
            vector< XMLPropertyState >& rPropStates,
            const Reference< XPropertySet >& rPropSet,
            const rtl::Reference< XMLPropertySetMapper >& rPropMapper,
            const bool bDefault )
    {
        XMLPropertyStates_Impl aPropStates;

        const uno::Sequence<OUString>& rApiNames = GetApiNames();

        Reference < XTolerantMultiPropertySet > xTolPropSet( rPropSet, UNO_QUERY );
        if (xTolPropSet.is())
        {
            if (!bDefault)
            {
                Sequence < beans::GetDirectPropertyTolerantResult > aResults(xTolPropSet->getDirectPropertyValuesTolerant(rApiNames));
                sal_Int32 nResultCount(aResults.getLength());
                if (nResultCount > 0)
                {
                    const beans::GetDirectPropertyTolerantResult *pResults = aResults.getConstArray();
                    FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
                    XMLPropertyState aNewProperty( -1 );
                    sal_uInt32 i = 0;
                    while (nResultCount > 0 && i < nCount)
                    {
                        if (pResults->Name == aPropIter->GetApiName())
                        {
                            aNewProperty.mnIndex = -1;
                            aNewProperty.maValue = pResults->Value;

                            for (auto const& index : aPropIter->GetIndexes())
                            {
                                aNewProperty.mnIndex = index;
                                aPropStates.AddPropertyState( aNewProperty );
                            }
                            ++pResults;
                            --nResultCount;
                        }
                        ++aPropIter;
                        ++i;
                    }
                }
            }
            else
            {
                Sequence < beans::GetPropertyTolerantResult > aResults(xTolPropSet->getPropertyValuesTolerant(rApiNames));
                OSL_ENSURE( rApiNames.getLength() == aResults.getLength(), "wrong implemented XTolerantMultiPropertySet" );
                const beans::GetPropertyTolerantResult *pResults = aResults.getConstArray();
                FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
                XMLPropertyState aNewProperty( -1 );
                sal_uInt32 nResultCount(aResults.getLength());
                OSL_ENSURE( nCount == nResultCount, "wrong implemented XTolerantMultiPropertySet??" );
                for( sal_uInt32 i = 0; i < nResultCount; ++i )
                {
                    if ((pResults->Result == beans::TolerantPropertySetResultType::SUCCESS) &&
                        ((pResults->State == PropertyState_DIRECT_VALUE) || (pResults->State == PropertyState_DEFAULT_VALUE)))
                    {
                        aNewProperty.mnIndex = -1;
                        aNewProperty.maValue = pResults->Value;

                        for (auto const& index : aPropIter->GetIndexes())
                        {
                            aNewProperty.mnIndex = index;
                            aPropStates.AddPropertyState( aNewProperty );
                        }
                    }
                    ++pResults;
                    ++aPropIter;
                }
            }
        }
        else
        {
            Sequence < PropertyState > aStates;
            const PropertyState *pStates = nullptr;
            Reference< XPropertyState > xPropState( rPropSet, UNO_QUERY );
            if( xPropState.is() )
            {
                aStates = xPropState->getPropertyStates( rApiNames );
                pStates = aStates.getConstArray();
            }

            Reference < XMultiPropertySet > xMultiPropSet( rPropSet, UNO_QUERY );
            if( xMultiPropSet.is() && !bDefault )
            {
                Sequence < Any > aValues;
                if( pStates )
                {
                    // step 1: get value count
                    sal_uInt32 nValueCount = 0;
                    sal_uInt32 i;

                    for( i = 0; i < nCount; ++i, ++pStates )
                    {
                        if( *pStates == PropertyState_DIRECT_VALUE )
                            nValueCount++;
                    }

                    if( nValueCount )
                    {
                        // step 2: collect property names
                        Sequence < OUString > aAPINames( nValueCount );
                        OUString *pAPINames = aAPINames.getArray();

                        ::std::vector< FilterPropertyInfoList_Impl::iterator > aPropIters;
                        aPropIters.reserve( nValueCount );

                        FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
                        OSL_ENSURE(aItr != aPropInfos.end(),"Invalid iterator!");

                        pStates = aStates.getConstArray();
                        i = 0;
                        while( i < nValueCount )
                        {
                            if( *pStates == PropertyState_DIRECT_VALUE )
                            {
                                *pAPINames++ = aItr->GetApiName();
                                aPropIters.push_back( aItr );
                                ++i;
                            }
                            ++aItr;
                            ++pStates;
                        }

                        aValues = xMultiPropSet->getPropertyValues( aAPINames );
                        const Any *pValues = aValues.getConstArray();

                        ::std::vector< FilterPropertyInfoList_Impl::iterator >::const_iterator
                            pPropIter = aPropIters.begin();

                        XMLPropertyState aNewProperty( -1 );
                        for( i = 0; i < nValueCount; ++i )
                        {
                            aNewProperty.mnIndex = -1;
                            aNewProperty.maValue = *pValues;

                            for (auto const& index : (*pPropIter)->GetIndexes())
                            {
                                aNewProperty.mnIndex = index;
                                aPropStates.AddPropertyState( aNewProperty );
                            }

                            ++pPropIter;
                            ++pValues;
                        }
                    }
                }
                else
                {
                    aValues = xMultiPropSet->getPropertyValues( rApiNames );
                    const Any *pValues = aValues.getConstArray();

                    FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
                    for(sal_uInt32 i = 0; i < nCount; ++i)
                    {
                        // The value is stored in the PropertySet itself, add to list.
                        XMLPropertyState aNewProperty( -1 );
                        aNewProperty.maValue = *pValues;
                        ++pValues;
                        for (auto const& index : aItr->GetIndexes())
                        {
                            aNewProperty.mnIndex = index;
                            aPropStates.AddPropertyState( aNewProperty );
                        }
                        ++aItr;
                    }
                }
            }
            else
            {
                FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
                for(sal_uInt32 i = 0; i < nCount; ++i)
                {
                    bool bDirectValue =
                        !pStates || *pStates == PropertyState_DIRECT_VALUE;
                    if( bDirectValue || bDefault )
                    {
                        // The value is stored in the PropertySet itself, add to list.
                        bool bGotValue = false;
                        XMLPropertyState aNewProperty( -1 );
                        for (auto const& index : aItr->GetIndexes())
                        {
                            if( bDirectValue ||
                                (rPropMapper->GetEntryFlags(index) &
                                                MID_FLAG_DEFAULT_ITEM_EXPORT) != 0 )
                            {
                                try
                                {
                                    if( !bGotValue )
                                    {
                                        aNewProperty.maValue =
                                            rPropSet->getPropertyValue( aItr->GetApiName() );
                                        bGotValue = true;
                                    }
                                    aNewProperty.mnIndex = index;
                                    aPropStates.AddPropertyState( aNewProperty );
                                }
                                catch( UnknownPropertyException& )
                                {
                                    // might be a problem of getImplemenetationId
                                    OSL_ENSURE( false, "unknown property in getPropertyValue" );
                                }

                            }
                        }
                    }

                    ++aItr;
                    if( pStates )
                        ++pStates;
                }
            }
        }
        aPropStates.FillPropertyStateVector(rPropStates);
    }

    }

    struct SvXMLExportPropertyMapper::Impl
    {
        typedef std::map<css::uno::Reference<css::beans::XPropertySetInfo>, std::unique_ptr<FilterPropertiesInfo_Impl>> CacheType;
        CacheType maCache;

        rtl::Reference<SvXMLExportPropertyMapper> mxNextMapper;
        rtl::Reference<XMLPropertySetMapper> mxPropMapper;

        OUString maStyleName;
    };

    // ctor/dtor , class SvXMLExportPropertyMapper

    SvXMLExportPropertyMapper::SvXMLExportPropertyMapper(
            const rtl::Reference< XMLPropertySetMapper >& rMapper ) :
        mpImpl(new Impl)
    {
        mpImpl->mxPropMapper = rMapper;
    }

    SvXMLExportPropertyMapper::~SvXMLExportPropertyMapper()
    {
    }

    void SvXMLExportPropertyMapper::ChainExportMapper(
            const rtl::Reference< SvXMLExportPropertyMapper>& rMapper )
    {
        // add map entries from rMapper to current map
        mpImpl->mxPropMapper->AddMapperEntry( rMapper->getPropertySetMapper() );
        // rMapper uses the same map as 'this'
        rMapper->mpImpl->mxPropMapper = mpImpl->mxPropMapper;

        // set rMapper as last mapper in current chain
        rtl::Reference< SvXMLExportPropertyMapper > xNext = mpImpl->mxNextMapper;
        if( xNext.is())
        {
            while (xNext->mpImpl->mxNextMapper.is())
                xNext = xNext->mpImpl->mxNextMapper;
            xNext->mpImpl->mxNextMapper = rMapper;
        }
        else
            mpImpl->mxNextMapper = rMapper;

        // if rMapper was already chained, correct
        // map pointer of successors
        xNext = rMapper;

        while (xNext->mpImpl->mxNextMapper.is())
        {
            xNext = xNext->mpImpl->mxNextMapper;
            xNext->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
        }
    }

    std::vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter(
        const uno::Reference<beans::XPropertySet>& rPropSet, bool bEnableFoFontFamily ) const
    {
        return Filter_(rPropSet, false, bEnableFoFontFamily);
    }

    std::vector<XMLPropertyState> SvXMLExportPropertyMapper::FilterDefaults(
        const uno::Reference<beans::XPropertySet>& rPropSet ) const
    {
        return Filter_(rPropSet, true, false/*bEnableFoFontFamily*/);
    }

    vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter_(
        const Reference<XPropertySet>& xPropSet, bool bDefault, bool bEnableFoFontFamily ) const
    {
        vector< XMLPropertyState > aPropStateArray;

        // Retrieve XPropertySetInfo and XPropertyState
        Reference< XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
        if( !xInfo.is() )
            return aPropStateArray;

        sal_Int32 nProps = mpImpl->mxPropMapper->GetEntryCount();

        FilterPropertiesInfo_Impl *pFilterInfo = nullptr;

        Impl::CacheType::iterator aIter = mpImpl->maCache.find(xInfo);
        if (aIter != mpImpl->maCache.end())
            pFilterInfo = (*aIter).second.get();

        bool bDelInfo = false;
        if( !pFilterInfo )
        {
            const SvtSaveOptions::ODFDefaultVersion nCurrentVersion( SvtSaveOptions().GetODFDefaultVersion() );
            pFilterInfo = new FilterPropertiesInfo_Impl;
            for( sal_Int32 i=0; i < nProps; i++ )
            {
                // Are we allowed to ask for the property? (MID_FLAG_NO_PROP..)
                // Does the PropertySet contain name of mpEntries-array ?
                const OUString& rAPIName = mpImpl->mxPropMapper->GetEntryAPIName( i );
                const sal_Int32 nFlags = mpImpl->mxPropMapper->GetEntryFlags( i );
                if( (0 == (nFlags & MID_FLAG_NO_PROPERTY_EXPORT)) &&
                    ( (0 != (nFlags & MID_FLAG_MUST_EXIST)) ||
                      xInfo->hasPropertyByName( rAPIName ) ) )
                {
                    const SvtSaveOptions::ODFDefaultVersion nEarliestODFVersionForExport(
                            mpImpl->mxPropMapper->GetEarliestODFVersionForExport(i));
                    if( nCurrentVersion >= nEarliestODFVersionForExport
                            || nCurrentVersion == SvtSaveOptions::ODFVER_UNKNOWN
                            || nEarliestODFVersionForExport == SvtSaveOptions::ODFVER_UNKNOWN )
                        pFilterInfo->AddProperty(rAPIName, i);
                }
            }

            // Check whether the property set info is destroyed if it is assigned to
            // a weak reference only; If it is destroyed, then every instance of
            // getPropertySetInfo returns a new object; such property set infos must
            // not be cached:
            WeakReference < XPropertySetInfo > xWeakInfo( xInfo );
            xInfo.clear();
            xInfo = xWeakInfo;
            if( xInfo.is() )
            {
                mpImpl->maCache.emplace(xInfo, std::unique_ptr<FilterPropertiesInfo_Impl>(pFilterInfo));
            }
            else
                bDelInfo = true;
        }

        if( pFilterInfo->GetPropertyCount() )
        {
            try
            {
                pFilterInfo->FillPropertyStateArray(
                    aPropStateArray, xPropSet, mpImpl->mxPropMapper, bDefault);
            }
            catch( UnknownPropertyException& )
            {
                // might be a problem of getImplemenetationId
                OSL_ENSURE( false, "unknown property in getPropertyStates" );
            }
        }

        // Call context-filter
        if( !aPropStateArray.empty() )
            ContextFilter(bEnableFoFontFamily, aPropStateArray, xPropSet);

        // Have to do if we change from a vector to a list or something like that

        if( bDelInfo )
            delete pFilterInfo;

        return aPropStateArray;
    }

    void SvXMLExportPropertyMapper::ContextFilter(
            bool bEnableFoFontFamily,
            vector< XMLPropertyState >& rProperties,
            const Reference< XPropertySet >& rPropSet ) const
    {
        // Derived class could implement this.
        if (mpImpl->mxNextMapper.is())
            mpImpl->mxNextMapper->ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
    }

    // Compares two Sequences of XMLPropertyState:
    //  1.Number of elements equal ?
    //  2.Index of each element equal ? (So I know whether the propertynames are the same)
    //  3.Value of each element equal ?
    bool SvXMLExportPropertyMapper::Equals(
            const vector< XMLPropertyState >& aProperties1,
            const vector< XMLPropertyState >& aProperties2 ) const
    {
        bool bRet = true;
        sal_uInt32 nCount = aProperties1.size();

        if( nCount == aProperties2.size() )
        {
            sal_uInt32 nIndex = 0;
            while( bRet && nIndex < nCount )
            {
                const XMLPropertyState& rProp1 = aProperties1[ nIndex ];
                const XMLPropertyState& rProp2 = aProperties2[ nIndex ];

                // Compare index. If equal, compare value
                if( rProp1.mnIndex == rProp2.mnIndex )
                {
                    if( rProp1.mnIndex != -1 )
                    {
                        // Now compare values
                        if ( (mpImpl->mxPropMapper->GetEntryType( rProp1.mnIndex ) &
                              XML_TYPE_BUILDIN_CMP ) != 0 )
                            // simple type ( binary compare )
                            bRet = ( rProp1.maValue == rProp2.maValue );
                        else
                            // complex type ( ask for compare-function )
                            bRet = mpImpl->mxPropMapper->GetPropertyHandler(
                                        rProp1.mnIndex )->equals( rProp1.maValue,
                                                                  rProp2.maValue );
                    }
                }
                else
                    bRet = false;

                nIndex++;
            }
        }
        else
            bRet = false;

        return bRet;
    }

    /** fills the given attribute list with the items in the given set
    void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
            const ::std::vector< XMLPropertyState >& rProperties,
            const SvXMLUnitConverter& rUnitConverter,
            const SvXMLNamespaceMap& rNamespaceMap,
            sal_uInt16 nFlags ) const
    {
        _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
                    nFlags, 0, -1, -1 );
    }

    void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
            const ::std::vector< XMLPropertyState >& rProperties,
            const SvXMLUnitConverter& rUnitConverter,
            const SvXMLNamespaceMap& rNamespaceMap,
            sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
            sal_uInt16 nFlags ) const
    {
        _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
                    nFlags, 0, nPropMapStartIdx, nPropMapEndIdx );
    }
    */

    void SvXMLExportPropertyMapper::exportXML(
            SvXMLExport& rExport,
            const ::std::vector< XMLPropertyState >& rProperties,
            SvXmlExportFlags nFlags,
            bool bUseExtensionNamespaceForGraphicProperties) const
    {
        exportXML(rExport, rProperties, -1, -1,  nFlags, bUseExtensionNamespaceForGraphicProperties);
    }

    void SvXMLExportPropertyMapper::exportXML(
            SvXMLExport& rExport,
            const ::std::vector< XMLPropertyState >& rProperties,
            sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
            SvXmlExportFlags nFlags, bool bUseExtensionNamespaceForGraphicProperties) const
    {
        sal_uInt16 nPropTypeFlags = 0;
        for( sal_uInt16 i=0; i<MAX_PROP_TYPES; ++i )
        {
            sal_uInt16 nPropType = aPropTokens[i].nType;
            if( 0==i || (nPropTypeFlags & (1 << nPropType)) != 0 )
            {
                sal_uInt16 nNamespace = XML_NAMESPACE_STYLE;
                if (bUseExtensionNamespaceForGraphicProperties &&
                    aPropTokens[i].eToken == xmloff::token::XML_GRAPHIC_PROPERTIES)
                {
                    nNamespace = XML_NAMESPACE_LO_EXT;
                    if (rExport.getDefaultVersion() <= SvtSaveOptions::ODFVER_012)
                    {
                        continue; // don't write for ODF <= 1.2
                    }
                }

                std::vector<sal_uInt16> aIndexArray;

                _exportXML( nPropType, nPropTypeFlags,
                            rExport.GetAttrList(), rProperties,
                            rExport.GetMM100UnitConverter(),
                            rExport.GetNamespaceMap(),
                            &aIndexArray,
                            nPropMapStartIdx, nPropMapEndIdx );

                if( rExport.GetAttrList().getLength() > 0 ||
                    (nFlags & SvXmlExportFlags::EMPTY) ||
                    !aIndexArray.empty() )
                {
                    SvXMLElementExport aElem( rExport, nNamespace,
                                      aPropTokens[i].eToken,
                                      bool(nFlags & SvXmlExportFlags::IGN_WS),
                                      false );

                    exportElementItems( rExport, rProperties, nFlags, aIndexArray );
                }
            }
        }
    }

    /** this method is called for every item that has the
        MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
    void SvXMLExportPropertyMapper::handleSpecialItem(
            SvXMLAttributeList& rAttrList,
            const XMLPropertyState& rProperty,
            const SvXMLUnitConverter& rUnitConverter,
            const SvXMLNamespaceMap& rNamespaceMap,
            const ::std::vector< XMLPropertyState > *pProperties,
            sal_uInt32 nIdx ) const
    {
        OSL_ENSURE(mpImpl->mxNextMapper.is(), "special item not handled in xml export");
        if (mpImpl->mxNextMapper.is())
            mpImpl->mxNextMapper->handleSpecialItem(
                rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx);
    }

    /** this method is called for every item that has the
        MID_FLAG_ELEMENT_EXPORT flag set */
    void SvXMLExportPropertyMapper::handleElementItem(
            SvXMLExport& rExport,
            const XMLPropertyState& rProperty,
            SvXmlExportFlags nFlags,
            const ::std::vector< XMLPropertyState > *pProperties,
            sal_uInt32 nIdx ) const
    {
        OSL_ENSURE(mpImpl->mxNextMapper.is(), "element item not handled in xml export");
        if (mpImpl->mxNextMapper.is())
            mpImpl->mxNextMapper->handleElementItem(rExport, rProperty, nFlags, pProperties, nIdx);
    }

    // protected methods

    /** fills the given attribute list with the items in the given set */
    void SvXMLExportPropertyMapper::_exportXML(
            sal_uInt16 nPropType, sal_uInt16& rPropTypeFlags,
            SvXMLAttributeList& rAttrList,
            const ::std::vector< XMLPropertyState >& rProperties,
            const SvXMLUnitConverter& rUnitConverter,
            const SvXMLNamespaceMap& rNamespaceMap,
            std::vector<sal_uInt16>* pIndexArray,
            sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx ) const
    {
        const sal_uInt32 nCount = rProperties.size();
        sal_uInt32 nIndex = 0;

        if( -1 == nPropMapStartIdx )
            nPropMapStartIdx = 0;
        if( -1 == nPropMapEndIdx )
            nPropMapEndIdx = mpImpl->mxPropMapper->GetEntryCount();

        while( nIndex < nCount )
        {
            sal_Int32 nPropMapIdx = rProperties[nIndex].mnIndex;
            if( nPropMapIdx >= nPropMapStartIdx &&
                nPropMapIdx < nPropMapEndIdx  )// valid entry?
            {
                sal_uInt32 nEFlags = mpImpl->mxPropMapper->GetEntryFlags(nPropMapIdx);
                sal_uInt16 nEPType = GET_PROP_TYPE(nEFlags);
                OSL_ENSURE(nEPType >= (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT),
                           "no prop type specified");
                rPropTypeFlags |= (1 << nEPType);
                if( nEPType == nPropType )
                {
                    // we have a valid map entry here, so lets use it...
                    if( ( nEFlags & MID_FLAG_ELEMENT_ITEM_EXPORT ) != 0 )
                    {
                        // element items do not add any properties,
                        // we export it later
                        if( pIndexArray )
                        {
                            pIndexArray->push_back( static_cast<sal_uInt16>(nIndex) );
                        }
                    }
                    else
                    {
                        _exportXML( rAttrList, rProperties[nIndex], rUnitConverter,
                                    rNamespaceMap, &rProperties, nIndex );
                    }
                }
            }

            nIndex++;
        }
    }

    void SvXMLExportPropertyMapper::_exportXML(
            SvXMLAttributeList& rAttrList,
            const XMLPropertyState& rProperty,
            const SvXMLUnitConverter& rUnitConverter,
            const SvXMLNamespaceMap& rNamespaceMap,
            const ::std::vector< XMLPropertyState > *pProperties,
            sal_uInt32 nIdx ) const
    {
        if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_SPECIAL_ITEM_EXPORT) != 0)
        {
            uno::Reference< container::XNameContainer > xAttrContainer;
            if( (rProperty.maValue >>= xAttrContainer) && xAttrContainer.is() )
            {
                SvXMLNamespaceMap *pNewNamespaceMap = nullptr;
                const SvXMLNamespaceMap *pNamespaceMap = &rNamespaceMap;

                uno::Sequence< OUString > aAttribNames( xAttrContainer->getElementNames() );
                const OUString* pAttribName = aAttribNames.getConstArray();

                const sal_Int32 nCount = aAttribNames.getLength();

                OUStringBuffer sNameBuffer;
                xml::AttributeData aData;
                for( sal_Int32 i=0; i < nCount; i++, pAttribName++ )
                {
                    xAttrContainer->getByName( *pAttribName ) >>= aData;
                    OUString sAttribName( *pAttribName );

                    // extract namespace prefix from attribute name if it exists
                    OUString sPrefix;
                    const sal_Int32 nColonPos =
                        pAttribName->indexOf( ':' );
                    if( nColonPos != -1 )
                        sPrefix = pAttribName->copy( 0, nColonPos );

                    if( !sPrefix.isEmpty() )
                    {
                        OUString sNamespace( aData.Namespace );

                        // if the prefix isn't defined yet or has another meaning,
                        // we have to redefine it now.
                        sal_uInt16 nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
                        if( USHRT_MAX == nKey || pNamespaceMap->GetNameByKey( nKey ) != sNamespace )
                        {
                            bool bAddNamespace = false;
                            if( USHRT_MAX == nKey )
                            {
                                // The prefix is unused, so it is sufficient
                                // to add it to the namespace map.
                                bAddNamespace = true;
                            }
                            else
                            {
                                // check if there is a prefix registered for the
                                // namespace URI
                                nKey = pNamespaceMap->GetKeyByName( sNamespace );
                                if( XML_NAMESPACE_UNKNOWN == nKey )
                                {
                                    // There is no prefix for the namespace, so
                                    // we have to generate one and have to add it.
                                    sal_Int32 n=0;
                                    OUString sOrigPrefix( sPrefix );
                                    do
                                    {
                                        sNameBuffer.append( sOrigPrefix );
                                        sNameBuffer.append( ++n );
                                        sPrefix = sNameBuffer.makeStringAndClear();
                                        nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
                                    }
                                    while( nKey != USHRT_MAX );

                                    bAddNamespace = true;
                                }
                                else
                                {
                                    // If there is a prefix for the namespace,
                                    // we reuse that.
                                    sPrefix = pNamespaceMap->GetPrefixByKey( nKey );
                                }
                                // In any case, the attribute name has to be adapted.
                                sNameBuffer.append(sPrefix).append(":").appendCopy(*pAttribName, nColonPos+1 );
                                sAttribName = sNameBuffer.makeStringAndClear();
                            }

                            if( bAddNamespace )
                            {
                                if( !pNewNamespaceMap )
                                {
                                    pNewNamespaceMap = new SvXMLNamespaceMap( rNamespaceMap );
                                    pNamespaceMap = pNewNamespaceMap;
                                }
                                pNewNamespaceMap->Add( sPrefix, sNamespace );
                                sNameBuffer.append( GetXMLToken(XML_XMLNS) ).append( ":" ).append( sPrefix );
                                rAttrList.AddAttribute( sNameBuffer.makeStringAndClear(),
                                                        sNamespace );
                            }
                        }
                    }
                    OUString sOldValue( rAttrList.getValueByName( sAttribName ) );
                    OSL_ENSURE( sOldValue.isEmpty(), "alien attribute exists already" );
                    OSL_ENSURE(aData.Type == GetXMLToken(XML_CDATA), "different type to our default type which should be written out");
                    if( sOldValue.isEmpty() )
                        rAttrList.AddAttribute( sAttribName, aData.Value );
                }

                delete pNewNamespaceMap;
            }
            else
            {
                handleSpecialItem( rAttrList, rProperty, rUnitConverter,
                                   rNamespaceMap, pProperties, nIdx );
            }
        }
        else if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_ELEMENT_ITEM_EXPORT ) == 0)
        {
            OUString aValue;
            const OUString sName = rNamespaceMap.GetQNameByKey(
                mpImpl->mxPropMapper->GetEntryNameSpace(rProperty.mnIndex),
                mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));

            bool bRemove = false;
            if ((mpImpl->mxPropMapper->GetEntryFlags( rProperty.mnIndex ) & MID_FLAG_MERGE_ATTRIBUTE) != 0)
            {
                aValue = rAttrList.getValueByName( sName );
                bRemove = true;
            }

            if (mpImpl->mxPropMapper->exportXML(aValue, rProperty, rUnitConverter))
            {
                if( bRemove )
                    rAttrList.RemoveAttribute( sName );
                rAttrList.AddAttribute( sName, aValue );
            }
        }
    }

    void SvXMLExportPropertyMapper::exportElementItems(
            SvXMLExport& rExport,
            const ::std::vector< XMLPropertyState >& rProperties,
            SvXmlExportFlags nFlags,
            const std::vector<sal_uInt16>& rIndexArray ) const
    {
        const sal_uInt16 nCount = rIndexArray.size();

        bool bItemsExported = false;
        for( sal_uInt16 nIndex = 0; nIndex < nCount; nIndex++ )
        {
            const sal_uInt16 nElement = rIndexArray[nIndex];

            OSL_ENSURE( 0 != (mpImpl->mxPropMapper->GetEntryFlags(
                    rProperties[nElement].mnIndex ) & MID_FLAG_ELEMENT_ITEM_EXPORT),
                    "wrong mid flag!" );

            rExport.IgnorableWhitespace();
            handleElementItem( rExport, rProperties[nElement],
                               nFlags, &rProperties, nElement );
            bItemsExported = true;
        }

        if( bItemsExported )
            rExport.IgnorableWhitespace();
    }

    const rtl::Reference<XMLPropertySetMapper>& SvXMLExportPropertyMapper::getPropertySetMapper() const
    {
        return mpImpl->mxPropMapper;
    }

    void SvXMLExportPropertyMapper::SetStyleName( const OUString& rStyleName )
    {
        mpImpl->maStyleName = rStyleName;
    }

    const OUString& SvXMLExportPropertyMapper::GetStyleName() const
    {
        return mpImpl->maStyleName;
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V560 A part of conditional expression is always false.

↑ V1029 Numeric Truncation Error. Result of the 'size' function is written to the 16-bit variable.