configmgr/source/backend/updatedata.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: updatedata.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "updatedata.hxx"
  35
  36 #include <com/sun/star/configuration/backend/NodeAttribute.hpp>
  37 #include <com/sun/star/configuration/backend/XLayerHandler.hpp>
  38
  39 #include <iterator>
  40 #include <algorithm>
  41
  42 namespace configmgr
  43 {
  44 // -----------------------------------------------------------------------------
  45     namespace backend
  46     {
  47 // -----------------------------------------------------------------------------
  48
  49 ElementUpdate::ElementUpdate(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask)
  50 : NamedUpdate(_aName)
  51 , m_pParent(_pParent)
  52 , m_nFlags(_nFlags)
  53 , m_nFlagsMask(_nFlagsMask)
  54 {
  55 }
  56 // -----------------------------------------------------------------------------
  57
  58 sal_Int16 ElementUpdate::updateFlags(sal_Int16 _nFlags) const
  59 {
  60     return (_nFlags & ~m_nFlagsMask) | (m_nFlags & m_nFlagsMask);
  61 }
  62 // -----------------------------------------------------------------------------
  63
  64 NodeUpdate * ElementUpdate::asNodeUpdate(bool )
  65 {
  66     return NULL;
  67 }
  68 // -----------------------------------------------------------------------------
  69
  70 PropertyUpdate  * ElementUpdate::asPropertyUpdate()
  71 {
  72     return NULL;
  73 }
  74 // -----------------------------------------------------------------------------
  75 // -----------------------------------------------------------------------------
  76
  77 NodeUpdate::NodeUpdate(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask, Op _op)
  78 : ElementUpdate(_pParent,_aName,_nFlags, _nFlagsMask)
  79 , m_aNodes()
  80 , m_aProperties()
  81 , m_aRemovedElements()
  82 , m_op(_op)
  83 {
  84 }
  85 // -----------------------------------------------------------------------------
  86
  87 NodeUpdate * NodeUpdate::asNodeUpdate(bool _bMerged)
  88 {
  89     return (!_bMerged || m_op == modify
  90             || (updateFlags() & backenduno::NodeAttribute::FUSE) != 0)
  91         ? this : NULL;
  92 }
  93 // -----------------------------------------------------------------------------
  94
  95 bool NodeUpdate::addNodeUpdate(rtl::Reference<ElementUpdate> const & _aNode)
  96 {
  97     OSL_PRECOND( _aNode.is(), "ERROR: NodeUpdate: Trying to add NULL node.");
  98     OSL_PRECOND( _aNode->getParent() == this, "ERROR: NodeUpdate: Node being added has wrong parent.");
  99     OSL_ENSURE(m_aNodes.find(_aNode->getName()) == m_aNodes.end(),
 100                 "NodeUpdate: Child node being added already exists in this node.");
 101
 102     return m_aNodes.insert( ElementList::value_type(_aNode->getName(),_aNode) ).second;
 103 }
 104 // -----------------------------------------------------------------------------
 105
 106 bool NodeUpdate::addPropertyUpdate(rtl::Reference<ElementUpdate> const & _aProp)
 107 {
 108     OSL_PRECOND( _aProp.is(), "ERROR: NodeUpdate: Trying to add NULL property.");
 109     OSL_PRECOND( _aProp->getParent() == this, "ERROR: NodeUpdate: Property being added has wrong parent.");
 110     OSL_ENSURE(m_aProperties.find(_aProp->getName()) == m_aProperties.end(),
 111                 "NodeUpdate: Property being added already exists in this node.");
 112
 113     return m_aProperties.insert( ElementList::value_type(_aProp->getName(),_aProp) ).second;
 114 }
 115 // -----------------------------------------------------------------------------
 116
 117 void NodeUpdate::removeNodeByName(rtl::OUString const & _aName)
 118 {
 119     ElementList::iterator it = m_aNodes.find(_aName);
 120     OSL_ENSURE(it != m_aNodes.end(),
 121                 "NodeUpdate: Child node being removed is not in this node.");
 122
 123     if (it != m_aNodes.end())
 124     {
 125         m_aRemovedElements.insert(*it);
 126         m_aNodes.erase(it);
 127     }
 128 }
 129 // -----------------------------------------------------------------------------
 130
 131 void NodeUpdate::removePropertyByName  (rtl::OUString const & _aName)
 132 {
 133     ElementList::iterator it = m_aProperties.find(_aName);
 134     OSL_ENSURE(it != m_aProperties.end(),
 135                 "NodeUpdate: Property being removed is not in this node.");
 136
 137     if (it != m_aProperties.end())
 138     {
 139         m_aRemovedElements.insert(*it);
 140         m_aProperties.erase(it);
 141     }
 142 }
 143 // -----------------------------------------------------------------------------
 144
 145 rtl::Reference<ElementUpdate> NodeUpdate::getNodeByName(rtl::OUString const & _aName) const
 146 {
 147     ElementList::const_iterator it = m_aNodes.find(_aName);
 148
 149     return it != m_aNodes.end() ? it->second : rtl::Reference<ElementUpdate>();
 150 }
 151 // -----------------------------------------------------------------------------
 152
 153 rtl::Reference<ElementUpdate> NodeUpdate::getPropertyByName  (rtl::OUString const & _aName) const
 154 {
 155     ElementList::const_iterator it = m_aProperties.find(_aName);
 156
 157     return it != m_aProperties.end() ? it->second : rtl::Reference<ElementUpdate>();
 158 }
 159 // -----------------------------------------------------------------------------
 160
 161 void NodeUpdate::writeChildrenToLayer(backenduno::XLayerHandler * _pLayer)
 162 {
 163     OSL_ASSERT(_pLayer);
 164     for (ElementList::const_iterator itP = beginProperties(); itP != endProperties(); ++itP)
 165         itP->second->writeToLayer(_pLayer);
 166
 167     for (ElementList::const_iterator itN = beginNodes(); itN != endNodes(); ++itN)
 168         itN->second->writeToLayer(_pLayer);
 169 }
 170 // -----------------------------------------------------------------------------
 171 // -----------------------------------------------------------------------------
 172
 173 NodeModification::NodeModification(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask, sal_Bool _bReset)
 174 : NodeUpdate(_pParent,_aName,_nFlags, _nFlagsMask, _bReset ? reset : modify)
 175 {
 176 }
 177 // -----------------------------------------------------------------------------
 178
 179 void NodeModification::writeToLayer(backenduno::XLayerHandler * _pLayer)
 180 {
 181     OSL_ASSERT(_pLayer);
 182
 183     if ( this->getOperation() == reset &&   // if we have an empty
 184         !this->changedFlags() &&            // 'reset' node, that means
 185         !this->hasChildren() )              // we need to write
 186         return;                             // nothing
 187
 188     _pLayer->overrideNode( this->getName(), this->updateFlags(), false );
 189     this->writeChildrenToLayer(_pLayer);
 190     _pLayer->endNode();
 191 }
 192 // -----------------------------------------------------------------------------
 193 // -----------------------------------------------------------------------------
 194
 195 NodeReplace::NodeReplace(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags)
 196 : NodeUpdate(_pParent,_aName,_nFlags, _nFlags, replace)
 197 , m_aTemplateName()
 198 , m_aTemplateComponent()
 199 {
 200 }
 201 // -----------------------------------------------------------------------------
 202
 203 NodeReplace::NodeReplace(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, rtl::OUString const & _aTemplateName, rtl::OUString const & _aTemplateComponent)
 204 : NodeUpdate(_pParent,_aName,_nFlags, _nFlags, replace)
 205 , m_aTemplateName(_aTemplateName)
 206 , m_aTemplateComponent(_aTemplateComponent)
 207 {
 208 }
 209 // -----------------------------------------------------------------------------
 210
 211 bool NodeReplace::hasTemplate() const
 212 {
 213     return m_aTemplateName.getLength() != 0;
 214 }
 215 // -----------------------------------------------------------------------------
 216
 217 void NodeReplace::writeToLayer(backenduno::XLayerHandler * _pLayer)
 218 {
 219     OSL_ASSERT(_pLayer);
 220
 221     if (this->hasTemplate())
 222     {
 223         backenduno::TemplateIdentifier aTemplate( m_aTemplateName, m_aTemplateComponent );
 224         _pLayer->addOrReplaceNodeFromTemplate( this->getName(), aTemplate, this->updateFlags() );
 225     }
 226     else
 227         _pLayer->addOrReplaceNode( this->getName(), this->updateFlags() );
 228
 229     this->writeChildrenToLayer(_pLayer);
 230     _pLayer->endNode();
 231 }
 232 // -----------------------------------------------------------------------------
 233 // -----------------------------------------------------------------------------
 234
 235 NodeDrop::NodeDrop(NodeUpdate * _pParent, rtl::OUString const & _aName)
 236 : ElementUpdate(_pParent,_aName,0,0)
 237 {
 238 }
 239 // -----------------------------------------------------------------------------
 240
 241 void NodeDrop::writeToLayer(backenduno::XLayerHandler * _pLayer)
 242 {
 243     OSL_ASSERT(_pLayer);
 244     _pLayer->dropNode(this->getName());
 245 }
 246 // -----------------------------------------------------------------------------
 247 // -----------------------------------------------------------------------------
 248
 249 PropertyUpdate::PropertyUpdate(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, sal_Int16 _nFlagsMask, uno::Type const & _aType)
 250 : ElementUpdate(_pParent,_aName,_nFlags,_nFlagsMask)
 251 , m_aValues()
 252 , m_aType(_aType)
 253 {}
 254 // -----------------------------------------------------------------------------
 255
 256 PropertyUpdate  * PropertyUpdate::asPropertyUpdate()
 257 {
 258     return this;
 259 }
 260 // -----------------------------------------------------------------------------
 261
 262 static uno::Any makeResetMarker()
 263 {
 264     uno::Reference< backenduno::XLayerHandler > xNull;
 265     return uno::makeAny(xNull);
 266 }
 267 // -----------------------------------------------------------------------------
 268
 269 inline bool PropertyUpdate::isResetMarker(uno::Any const & _aValue)
 270 {
 271     OSL_ENSURE( _aValue.getValueTypeClass() != uno::TypeClass_INTERFACE ||
 272                 _aValue == makeResetMarker() && _aValue.getValueType() == makeResetMarker().getValueType(),
 273                 "Unexpected any: Interface reference will be taken as reset marker");
 274
 275     return _aValue.getValueTypeClass() == uno::TypeClass_INTERFACE;
 276 }
 277 // -----------------------------------------------------------------------------
 278
 279 uno::Any const & PropertyUpdate::getResetMarker()
 280 {
 281     static uno::Any const aMarker = makeResetMarker();
 282
 283     OSL_ASSERT( isResetMarker(aMarker) );
 284
 285     return aMarker;
 286 }
 287 // -----------------------------------------------------------------------------
 288
 289 bool PropertyUpdate::setValueFor(rtl::OUString const & _aLocale, uno::Any const & _aValueUpdate)
 290 {
 291     OSL_PRECOND( !isResetMarker(_aValueUpdate), "PropertyUpdate: ERROR: Trying to set a reset marker as regular value" );
 292
 293     OSL_ENSURE(m_aValues.find(_aLocale) == m_aValues.end(),
 294                 "PropertyUpdate: Locale being added already has a value in this property.");
 295
 296     if (_aValueUpdate.hasValue())
 297     {
 298         if (m_aType.getTypeClass() == uno::TypeClass_ANY)
 299             m_aType = _aValueUpdate.getValueType();
 300
 301         else
 302             OSL_ENSURE( m_aType == _aValueUpdate.getValueType() ||
 303                         m_aType == uno::Type(),
 304                         "ValueType mismatch in PropertyUpdate");
 305     }
 306     return m_aValues.insert( ValueList::value_type(_aLocale,_aValueUpdate) ).second;
 307 }
 308 // -----------------------------------------------------------------------------
 309
 310 bool PropertyUpdate::resetValueFor(rtl::OUString const & _aLocale)
 311 {
 312     OSL_ENSURE(m_aValues.find(_aLocale) == m_aValues.end(),
 313                 "PropertyUpdate: Locale being reset already has a value in this property.");
 314
 315     return m_aValues.insert( ValueList::value_type(_aLocale,getResetMarker()) ).second;
 316 }
 317 // -----------------------------------------------------------------------------
 318
 319 void PropertyUpdate::removeValueFor(rtl::OUString const & _aLocale)
 320 {
 321     OSL_ENSURE(m_aValues.find(_aLocale) != m_aValues.end(),
 322                 "PropertyUpdate: Locale being removed is not in this node.");
 323
 324     m_aValues.erase(_aLocale);
 325 }
 326 // -----------------------------------------------------------------------------
 327
 328 void PropertyUpdate::finishValue()
 329 {
 330     if (m_aType.getTypeClass() == uno::TypeClass_ANY)
 331         m_aType = uno::Type();
 332 }
 333 // -----------------------------------------------------------------------------
 334
 335 bool PropertyUpdate::hasValueFor(rtl::OUString const & _aLocale) const
 336 {
 337     ValueList::const_iterator it = m_aValues.find(_aLocale);
 338
 339     return it != m_aValues.end() && ! isResetMarker(it->second);
 340 }
 341 // -----------------------------------------------------------------------------
 342
 343 bool PropertyUpdate::hasResetFor(rtl::OUString const & _aLocale) const
 344 {
 345     ValueList::const_iterator it = m_aValues.find(_aLocale);
 346
 347     return it != m_aValues.end() && isResetMarker(it->second);
 348 }
 349 // -----------------------------------------------------------------------------
 350
 351 bool PropertyUpdate::hasChangeFor(rtl::OUString const & _aLocale) const
 352 {
 353     ValueList::const_iterator it = m_aValues.find(_aLocale);
 354
 355     return it != m_aValues.end();
 356 }
 357 // -----------------------------------------------------------------------------
 358
 359 uno::Any PropertyUpdate::getValueFor(rtl::OUString const & _aLocale) const
 360 {
 361     ValueList::const_iterator it = m_aValues.find(_aLocale);
 362
 363     OSL_ENSURE(it != m_aValues.end() && !isResetMarker(it->second),
 364                 "PropertyUpdate: Should not call getValue() unless hasValue() returns true" );
 365
 366     return it != m_aValues.end() && !isResetMarker(it->second) ? it->second : uno::Any();
 367 }
 368 // -----------------------------------------------------------------------------
 369
 370 void PropertyUpdate::writeValueToLayer(backenduno::XLayerHandler * _pLayer, uno::Any const & _aValue)
 371 {
 372     OSL_ASSERT(_pLayer);
 373     if ( !isResetMarker(_aValue) )
 374         _pLayer->setPropertyValue(_aValue);
 375
 376     // else - to reset - do nothing
 377 }
 378 // -----------------------------------------------------------------------------
 379
 380 void PropertyUpdate::writeValueToLayerFor(backenduno::XLayerHandler * _pLayer, uno::Any const & _aValue, rtl::OUString const & _aLocale)
 381 {
 382     OSL_ASSERT(_pLayer);
 383     if (_aLocale == this->primarySlot())
 384         this->writeValueToLayer(_pLayer,_aValue);
 385
 386     else if ( !isResetMarker(_aValue) )
 387         _pLayer->setPropertyValueForLocale(_aValue,_aLocale);
 388
 389     // else - to reset - do nothing
 390 }
 391 // -----------------------------------------------------------------------------
 392
 393 void PropertyUpdate::writeValuesToLayer(backenduno::XLayerHandler * _pLayer)
 394 {
 395     OSL_ASSERT(_pLayer);
 396     for (ValueList::const_iterator itV = beginValues(); itV != endValues(); ++itV)
 397         this->writeValueToLayerFor(_pLayer, itV->second, itV->first);
 398 }
 399 // -----------------------------------------------------------------------------
 400
 401 void PropertyUpdate::writeToLayer(backenduno::XLayerHandler * _pLayer)
 402 {
 403     OSL_ASSERT(_pLayer);
 404
 405     _pLayer->overrideProperty( this->getName(), this->updateFlags(), this->m_aType, false );
 406     this->writeValuesToLayer(_pLayer);
 407     _pLayer->endProperty();
 408 }
 409 // -----------------------------------------------------------------------------
 410 // -----------------------------------------------------------------------------
 411
 412
 413 PropertyAdd::PropertyAdd(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, uno::Type const & _aType)
 414 : ElementUpdate(_pParent,_aName,_nFlags,_nFlags)
 415 , m_aValueType(_aType)
 416 , m_aValue()
 417 {
 418
 419 }
 420 // -----------------------------------------------------------------------------
 421
 422 PropertyAdd::PropertyAdd(NodeUpdate * _pParent, rtl::OUString const & _aName, sal_Int16 _nFlags, uno::Any const & _aValue)
 423 : ElementUpdate(_pParent,_aName,_nFlags,_nFlags)
 424 , m_aValueType(_aValue.getValueType())
 425 , m_aValue(_aValue)
 426 {
 427 }
 428 // -----------------------------------------------------------------------------
 429
 430 void PropertyAdd::writeToLayer(backenduno::XLayerHandler * _pLayer)
 431 {
 432     OSL_ASSERT(_pLayer);
 433     if (this->hasValue())
 434         _pLayer->addPropertyWithValue(this->getName(),this->updateFlags(),this->getValue());
 435     else
 436         _pLayer->addProperty(this->getName(),this->updateFlags(),this->getValueType());
 437 }
 438 // -----------------------------------------------------------------------------
 439 // -----------------------------------------------------------------------------
 440
 441 PropertyReset::PropertyReset(NodeUpdate * _pParent, rtl::OUString const & _aName)
 442 : ElementUpdate(_pParent,_aName,0,0)
 443 {
 444 }
 445 // -----------------------------------------------------------------------------
 446
 447 void PropertyReset::writeToLayer(backenduno::XLayerHandler * _pLayer)
 448 {
 449     (void) _pLayer; // avoid warning about unused parameter
 450     OSL_ASSERT(_pLayer);
 451     // skip - nothing to write
 452 }
 453 // -----------------------------------------------------------------------------
 454 // -----------------------------------------------------------------------------
 455     } // namespace backend
 456
 457 // -------------------------------------------------------------------------
 458 } // namespace configmgr