/************************************************************************* * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: XMLPropertyBackpatcher.cxx,v $ * * $Revision: 1.7 $ * * last change: $Author: obo $ $Date: 2006-09-17 11:10:06 $ * * The Contents of this file are made available subject to * the terms of GNU Lesser General Public License Version 2.1. * * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2005 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library 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 for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_xmloff.hxx" #ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_ #include #endif #ifndef _COM_SUN_STAR_UNO_REFERENCE_H_ #include #endif #ifndef _RTL_USTRING #include #endif #ifndef _TOOLS_DEBUG_HXX #include #endif #ifndef _XMLOFF_XMLPROPERTYBACKPATCHER_HXX #include "XMLPropertyBackpatcher.hxx" #endif #ifndef _XMLOFF_TEXTIMP_HXX_ #include "txtimp.hxx" // XMLTextImportHelper partially implemented here #endif using ::rtl::OUString; using ::std::vector; using ::std::map; using ::com::sun::star::uno::Reference; using ::com::sun::star::uno::Any; using ::com::sun::star::beans::XPropertySet; template XMLPropertyBackpatcher::XMLPropertyBackpatcher( const ::rtl::OUString& sPropName) : sPropertyName(sPropName) , bDefaultHandling(sal_False) , bPreserveProperty(sal_False) , sPreservePropertyName() { } template XMLPropertyBackpatcher::XMLPropertyBackpatcher( const OUString& sPropName, const OUString& sPreserveName, sal_Bool bDefault, A aDef) : sPropertyName(sPropName) , bDefaultHandling(bDefault) , bPreserveProperty(sPreserveName.getLength()>0) , sPreservePropertyName(sPreserveName) , aDefault(aDef) { } template XMLPropertyBackpatcher::XMLPropertyBackpatcher( const sal_Char* pPropName) : bDefaultHandling(sal_False) , bPreserveProperty(sal_False) { DBG_ASSERT(pPropName != NULL, "need property name"); sPropertyName = OUString::createFromAscii(pPropName); } template XMLPropertyBackpatcher::XMLPropertyBackpatcher( const sal_Char* pPropName, const sal_Char* pPreservePropName, sal_Bool bDefault, A aDef) : bDefaultHandling(bDefault) , bPreserveProperty(pPreservePropName != NULL) , aDefault(aDef) { DBG_ASSERT(pPropName != NULL, "need property name"); sPropertyName = OUString::createFromAscii(pPropName); if (pPreservePropName != NULL) { sPreservePropertyName = OUString::createFromAscii(pPreservePropName); } } template XMLPropertyBackpatcher::~XMLPropertyBackpatcher() { SetDefault(); } template void XMLPropertyBackpatcher::ResolveId( const OUString& sName, A aValue) { // insert ID into ID map aIDMap[sName] = aValue; // backpatch old references, if backpatch list exists if (aBackpatchListMap.count(sName)) { // aah, we have a backpatch list! BackpatchListType* pList = (BackpatchListType*)aBackpatchListMap[sName]; // a) remove list from list map aBackpatchListMap.erase(sName); // b) for every item, set SequenceNumber // (and preserve Property, if appropriate) Any aAny; aAny <<= aValue; if (bPreserveProperty) { // preserve version for(BackpatchListType::iterator aIter = pList->begin(); aIter != pList->end(); aIter++) { Reference xProp = (*aIter); Any aPres = xProp->getPropertyValue(sPreservePropertyName); xProp->setPropertyValue(sPropertyName, aAny); xProp->setPropertyValue(sPreservePropertyName, aPres); } } else { // without preserve for(BackpatchListType::iterator aIter = pList->begin(); aIter != pList->end(); aIter++) { (*aIter)->setPropertyValue(sPropertyName, aAny); } } // c) delete list delete pList; } // else: no backpatch list -> then we're finished } template void XMLPropertyBackpatcher::SetProperty( const Reference & xPropSet, const OUString& sName) { Reference xNonConstPropSet(xPropSet); SetProperty(xNonConstPropSet, sName); } template void XMLPropertyBackpatcher::SetProperty( Reference & xPropSet, const OUString& sName) { if (aIDMap.count(sName)) { // we know this ID -> set property Any aAny; aAny <<= aIDMap[sName]; xPropSet->setPropertyValue(sPropertyName, aAny); } else { // ID unknown -> into backpatch list for later fixup if (! aBackpatchListMap.count(sName)) { // create backpatch list for this name BackpatchListType* pTmp = new BackpatchListType() ; aBackpatchListMap[sName] = (void*)pTmp; } // insert footnote ((BackpatchListType*)aBackpatchListMap[sName])->push_back(xPropSet); } } template void XMLPropertyBackpatcher::SetDefault() { if (bDefaultHandling) { // not implemented yet } } // force instantiation of templates template class XMLPropertyBackpatcher; template class XMLPropertyBackpatcher; // // XMLTextImportHelper // // Code from XMLTextImportHelper using the XMLPropertyBackpatcher is // implemented here. The reason is that in the unxsols2 environment, // all templates are instatiated as file local (switch // -instances=static), and thus are not accessible from the outside. // // The previous solution was to force additional instantiation of // XMLPropertyBackpatcher in txtimp.cxx. This solution combines all // usage of the XMLPropertyBackpatcher in XMLPropertyBackpatcher.cxx // instead. // XMLPropertyBackpatcher& XMLTextImportHelper::GetFootnoteBP() { if (NULL == pFootnoteBackpatcher) { pFootnoteBackpatcher = new XMLPropertyBackpatcher(sSequenceNumber); } return *pFootnoteBackpatcher; } XMLPropertyBackpatcher& XMLTextImportHelper::GetSequenceIdBP() { if (NULL == pSequenceIdBackpatcher) { pSequenceIdBackpatcher = new XMLPropertyBackpatcher(sSequenceNumber); } return *pSequenceIdBackpatcher; } XMLPropertyBackpatcher& XMLTextImportHelper::GetSequenceNameBP() { if (NULL == pSequenceNameBackpatcher) { pSequenceNameBackpatcher = new XMLPropertyBackpatcher(sSourceName); } return *pSequenceNameBackpatcher; } void XMLTextImportHelper::InsertFootnoteID( const OUString& sXMLId, sal_Int16 nAPIId) { GetFootnoteBP().ResolveId(sXMLId, nAPIId); } void XMLTextImportHelper::ProcessFootnoteReference( const OUString& sXMLId, const Reference & xPropSet) { GetFootnoteBP().SetProperty(xPropSet, sXMLId); } void XMLTextImportHelper::InsertSequenceID( const OUString& sXMLId, const OUString& sName, sal_Int16 nAPIId) { GetSequenceIdBP().ResolveId(sXMLId, nAPIId); GetSequenceNameBP().ResolveId(sXMLId, sName); } void XMLTextImportHelper::ProcessSequenceReference( const OUString& sXMLId, const Reference & xPropSet) { GetSequenceIdBP().SetProperty(xPropSet, sXMLId); GetSequenceNameBP().SetProperty(xPropSet, sXMLId); } void XMLTextImportHelper::_FinitBackpatcher() { delete pFootnoteBackpatcher; delete pSequenceIdBackpatcher; delete pSequenceNameBackpatcher; }