configmgr/source/treemgr/nodechangeimpl.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: nodechangeimpl.cxx,v $
  10  * $Revision: 1.22 $
  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 "nodechangeimpl.hxx"
  35 #include "nodechangeinfo.hxx"
  36 #include "nodeimpl.hxx"
  37 #include "tree.hxx"
  38 #include "configset.hxx"
  39 #include "setnodeimpl.hxx"
  40 #include "groupnodeimpl.hxx"
  41 #include "valuenode.hxx"
  42 #include "change.hxx"
  43
  44 namespace configmgr
  45 {
  46     namespace configuration
  47     {
  48 //-----------------------------------------------------------------------------
  49
  50 //-----------------------------------------------------------------------------
  51 // All Changes:NodeChangeImpl  - common base
  52 //-----------------------------------------------------------------------------
  53
  54 // life cycle states for a NodeChangeImpl
  55 enum { eTestedChange = 0x01, eAppliedChange = 0x02, eNoCheck = 0x07 };
  56 //-----------------------------------------------------------------------------
  57
  58 NodeChangeImpl::NodeChangeImpl(bool bNoCheck)
  59 : m_aAffectedTree()
  60 , m_nAffectedNode(0)
  61 , m_nState(0)
  62 {
  63     if (bNoCheck) m_nState = eNoCheck;
  64 }
  65 //-----------------------------------------------------------------------------
  66
  67 view::ViewTreeAccess NodeChangeImpl::getTargetView()
  68 {
  69     OSL_ENSURE( m_aAffectedTree.is(), "ERROR: Configuration Change: Target Tree Access has not been set up" );
  70
  71     return view::ViewTreeAccess(m_aAffectedTree.get());
  72 }
  73 //-----------------------------------------------------------------------------
  74
  75 rtl::Reference<Tree> NodeChangeImpl::getTargetTree() const
  76 {
  77     rtl::Reference<Tree> aRet = m_aAffectedTree;
  78     OSL_ENSURE( aRet.is(), "ERROR: Configuration Change: Target Tree has not been set up" );
  79
  80     return aRet;
  81 }
  82 //-----------------------------------------------------------------------------
  83
  84 unsigned int NodeChangeImpl::getTargetNode() const
  85 {
  86     unsigned int nRet = m_nAffectedNode;
  87     OSL_ENSURE( nRet != 0, "ERROR: Configuration Change: Target Node has not been set up" );
  88     OSL_ENSURE( m_aAffectedTree.is() && m_aAffectedTree->isValidNode(nRet),
  89                 "ERROR: Configuration Change: Changing Node does not match tree" );
  90
  91     return nRet;
  92 }
  93 //-----------------------------------------------------------------------------
  94
  95 void NodeChangeImpl::setTarget(view::Node _aAffectedNode)
  96 {
  97     this->setTarget(_aAffectedNode.tree(), _aAffectedNode.get_offset());
  98
  99 }
 100 void NodeChangeImpl::setTarget(rtl::Reference<Tree> const& _aAffectedTree, unsigned int _nAffectedNode)
 101 {
 102     OSL_ENSURE(m_nState == 0 || (!m_aAffectedTree.is() && m_nState == eNoCheck), "WARNING: Configuration: Retargeting change that already was tested or applied");
 103
 104     OSL_ENSURE( _aAffectedTree.is(), "ERROR: Configuration Change: NULL Target Tree is not allowed" );
 105     OSL_ENSURE( _nAffectedNode, "ERROR: Configuration Change: NULL Target Node is not allowed" );
 106     OSL_ENSURE( _aAffectedTree->isValidNode(_nAffectedNode), "ERROR: Configuration Change: Target Node does not match Tree" );
 107
 108     if (m_nState != eNoCheck) m_nState = 0; // previous checks are invalidated
 109
 110     m_aAffectedTree = _aAffectedTree;
 111     m_nAffectedNode = _nAffectedNode;
 112 }
 113 //-----------------------------------------------------------------------------
 114
 115 bool NodeChangeImpl::isChange(bool bAllowUntested) const
 116 {
 117     OSL_ENSURE(bAllowUntested || (m_nState & eTestedChange), "WARNING: Configuration: Change was not tested  - isChange is meaningless");
 118
 119     if (m_nState == eNoCheck)
 120         return true;
 121
 122     if (!(m_nState & eTestedChange))
 123         return bAllowUntested;
 124
 125     return doIsChange();
 126 }
 127 //-----------------------------------------------------------------------------
 128
 129 sal_uInt32 NodeChangeImpl::getChangeDataCount() const
 130 {
 131     OSL_PRECOND(m_nState & eTestedChange, "WARNING: Configuration: Change was not tested  - change data count may be incorrect");
 132
 133     return  doGetChangeCount();
 134 }
 135 //-----------------------------------------------------------------------------
 136
 137 bool NodeChangeImpl::fillChangeData(NodeChangeData& rChange, sal_uInt32 _ix) const
 138 {
 139     OSL_PRECOND(_ix < doGetChangeCount(), "ERROR: Configuration: Change index out of range");
 140     OSL_PRECOND(m_nState & eTestedChange, "WARNING: Configuration: Change was not tested  - fillChange is partially meaningless");
 141
 142     return doFillChange(rChange, _ix) || rChange.isDataChange(); // force true if the data is signaling change
 143 }
 144 //-----------------------------------------------------------------------------
 145
 146 bool NodeChangeImpl::fillChangeLocation(NodeChangeLocation& rChange, sal_uInt32 _ix) const
 147 {
 148     if (!m_aAffectedTree.is()) return false;
 149
 150     rChange.setBase( NodeID(this->getTargetTree().get(), this->getTargetNode()) );
 151
 152     rChange.setAccessor( this->doGetChangingNodePath(_ix) );
 153
 154     rChange.setAffected( NodeID(this->getTargetTree().get(), this->getTargetNode()) );
 155
 156     rChange.setChangingSubnode( this->doIsChangingSubnode() );
 157
 158     return true;
 159 }
 160 //-----------------------------------------------------------------------------
 161
 162 bool NodeChangeImpl::fillChangeInfo(NodeChangeInformation& rChange, sal_uInt32 _ix) const
 163 {
 164     return fillChangeLocation(rChange.location, _ix) & fillChangeData(rChange.change, _ix);
 165 }
 166 //-----------------------------------------------------------------------------
 167
 168 void NodeChangeImpl::test()
 169 {
 170     if (!(m_nState & eTestedChange))
 171     {
 172         doTest(implGetTarget());
 173         m_nState |= eTestedChange;
 174     }
 175 }
 176 //-----------------------------------------------------------------------------
 177
 178 void NodeChangeImpl::apply()
 179 {
 180     if (!(m_nState & eAppliedChange))
 181     {
 182         implApply();
 183
 184         OSL_ENSURE(m_nState & eAppliedChange, "ERROR: Configuration: Change could not be applied");
 185         OSL_ENSURE(m_nState & eTestedChange, "ERROR: Configuration: Change was not tested while applied");
 186     }
 187     else
 188         OSL_ENSURE(m_nState & eTestedChange, "ERROR: Configuration: Change marked applied but not tested");
 189 }
 190 //-----------------------------------------------------------------------------
 191
 192 // default count is 1
 193 sal_uInt32 NodeChangeImpl::doGetChangeCount() const
 194 {
 195     return  1;
 196 }
 197 //-----------------------------------------------------------------------------
 198
 199 /// apply this change to the given node - start state is nState (which is then updated)
 200 void NodeChangeImpl::implApply()
 201 {
 202     OSL_ASSERT( !(m_nState & eAppliedChange)); // Caller must check
 203
 204     view::Node aTarget = implGetTarget();
 205
 206     if (!(m_nState & eTestedChange))  // Test checks the old value if there is realy a change
 207     {                               // for eventlisteners to say "the old value is kept"
 208         doTest(aTarget);
 209         m_nState |= eTestedChange;
 210     }
 211
 212     doApply(aTarget);
 213     m_nState |= eAppliedChange;
 214 }
 215 //-----------------------------------------------------------------------------
 216
 217 view::Node NodeChangeImpl::implGetTarget()
 218 {
 219     OSL_ENSURE(m_aAffectedTree.is(), "ERROR: Configuration Change: no target tree set");
 220
 221     OSL_ENSURE(m_aAffectedTree->isValidNode(m_nAffectedNode), "ERROR: Configuration Change: target node not in target tree");
 222
 223     view::Node aTarget = getTargetView().makeNode(m_nAffectedNode);
 224     OSL_ENSURE(aTarget.is(), "ERROR: Configuration: No target for change");
 225     return aTarget;
 226 }
 227 //-----------------------------------------------------------------------------
 228
 229 //-----------------------------------------------------------------------------
 230 // Value operations: ValueChangeImpl = common base
 231 //-----------------------------------------------------------------------------
 232
 233 ValueChangeImpl::ValueChangeImpl()
 234 : m_aNewValue()
 235 , m_aOldValue()
 236 {
 237 }
 238 //-----------------------------------------------------------------------------
 239
 240 ValueChangeImpl::ValueChangeImpl(com::sun::star::uno::Any const& aNewValue)
 241 : m_aNewValue(aNewValue)
 242 , m_aOldValue()
 243 {
 244 }
 245 //-----------------------------------------------------------------------------
 246
 247 ValueChangeImpl::ValueChangeImpl(com::sun::star::uno::Any const& aNewValue, com::sun::star::uno::Any const& aOldValue)
 248 : NodeChangeImpl(true)
 249 , m_aNewValue(aNewValue)
 250 , m_aOldValue(aOldValue)
 251 {
 252 }
 253 //-----------------------------------------------------------------------------
 254
 255 ValueChangeImpl::~ValueChangeImpl()
 256 {
 257 }
 258 //-----------------------------------------------------------------------------
 259
 260 void ValueChangeImpl::setTarget(view::GroupNode const& _aParentNode, rtl::OUString const& sNodeName)
 261 {
 262     OSL_ENSURE(sNodeName.getLength() != 0, "ValueChangeTarget is being set without a name");
 263
 264     NodeChangeImpl::setTarget(_aParentNode.node());
 265     m_aName = sNodeName;
 266 }
 267 //-----------------------------------------------------------------------------
 268
 269 void ValueChangeImpl::setTarget(rtl::Reference<Tree> const& aAffectedTree, unsigned int nParentNode, rtl::OUString const& sNodeName)
 270 {
 271     OSL_ENSURE(sNodeName.getLength() != 0, "ValueChangeTarget is being set without a name");
 272
 273     NodeChangeImpl::setTarget(aAffectedTree,nParentNode);
 274     m_aName = sNodeName;
 275 }
 276 //-----------------------------------------------------------------------------
 277
 278 RelativePath ValueChangeImpl::doGetChangingNodePath(sal_uInt32 ) const
 279 {
 280     return RelativePath( Path::wrapSimpleName(m_aName) );
 281 }
 282 //-----------------------------------------------------------------------------
 283
 284 bool ValueChangeImpl::doIsChangingSubnode() const
 285 {
 286     return m_aName.getLength() != 0;
 287 }
 288 //-----------------------------------------------------------------------------
 289
 290 bool ValueChangeImpl::doIsChange() const
 291 {
 292     return !!(getNewValue() != getOldValue());
 293 }
 294 //-----------------------------------------------------------------------------
 295
 296 bool ValueChangeImpl::doFillChange(NodeChangeData& rChange, sal_uInt32) const
 297 {
 298     rChange.unoData.newValue = getNewValue();
 299     rChange.unoData.oldValue = getOldValue();
 300     return rChange.unoData.isDataChange();
 301 }
 302 //-----------------------------------------------------------------------------
 303
 304 void ValueChangeImpl::doTest( view::Node const& rTarget)
 305 {
 306     view::ViewTreeAccess aTargetView = getTargetView();
 307
 308     OSL_ENSURE(rTarget.isGroupNode(), "ERROR: Configuration: Target type mismatch: expected a group node holding the value");
 309
 310     ValueMemberNode aValueTarget = aTargetView.getValue( view::GroupNode(rTarget), m_aName );
 311
 312     OSL_ENSURE(aValueTarget.isValid(), "ERROR: Configuration: Target missing: could not find the changing value");
 313
 314     preCheckValue(aValueTarget, m_aOldValue, m_aNewValue);
 315 }
 316 //-----------------------------------------------------------------------------
 317
 318 void ValueChangeImpl::doApply( view::Node const& rTarget)
 319 {
 320     view::ViewTreeAccess aTargetView = getTargetView();
 321
 322     OSL_ENSURE(rTarget.isGroupNode(), "ERROR: Configuration: Target type mismatch: expected a group node holding the value");
 323
 324     ValueMemberUpdate aValueTarget = aTargetView.getValueForUpdate( view::GroupNode(rTarget), m_aName );
 325
 326     OSL_ENSURE(aValueTarget.isValid(), "ERROR: Configuration: Target missing: could not find the changing value");
 327
 328     doApplyChange(aValueTarget);
 329     configmgr::configuration::ValueMemberNode aNode(aValueTarget.getNode());
 330     postCheckValue(aNode, m_aNewValue); // Sideeffect: m_aNewValue will be changed
 331 }
 332 //-----------------------------------------------------------------------------
 333
 334 void ValueChangeImpl::preCheckValue(ValueMemberNode& rNode, com::sun::star::uno::Any& rOld, com::sun::star::uno::Any& )
 335 {
 336     com::sun::star::uno::Any aPrevValue = rNode.getValue();
 337     OSL_ENSURE(!rOld.hasValue() || rOld == aPrevValue, "ERROR: Configuration: Stored old value of target does not match the actual value");
 338     rOld = aPrevValue;
 339 }
 340 //-----------------------------------------------------------------------------
 341
 342 void ValueChangeImpl::postCheckValue(ValueMemberNode& rNode, com::sun::star::uno::Any& rNew)
 343 {
 344     com::sun::star::uno::Any aResultValue = rNode.getValue();
 345     OSL_ENSURE(!rNew.hasValue() || rNew == aResultValue, "ERROR: Configuration: New value of target does not match the predicted result");
 346     rNew = aResultValue;
 347 }
 348 //-----------------------------------------------------------------------------
 349
 350 //-----------------------------------------------------------------------------
 351 // Value operations: ValueReplaceImpl = set local value
 352 //-----------------------------------------------------------------------------
 353
 354 ValueReplaceImpl::ValueReplaceImpl(com::sun::star::uno::Any const& aNewValue)
 355 :ValueChangeImpl(aNewValue)
 356 {
 357 }
 358 //-----------------------------------------------------------------------------
 359
 360 ValueReplaceImpl::ValueReplaceImpl(com::sun::star::uno::Any const& aNewValue, com::sun::star::uno::Any const& aOldValue)
 361 :ValueChangeImpl(aNewValue, aOldValue)
 362 {
 363 }
 364 //-----------------------------------------------------------------------------
 365
 366 void ValueReplaceImpl::doApplyChange( ValueMemberUpdate& rNode)
 367 {
 368     rNode.setValue(getNewValue());
 369 }
 370 //-----------------------------------------------------------------------------
 371
 372 bool ValueReplaceImpl::doFillChange( NodeChangeData& rChange, sal_uInt32 _ix) const
 373 {
 374     rChange.type = NodeChangeData::eSetValue;
 375     return ValueChangeImpl::doFillChange(rChange, _ix);
 376 }
 377
 378 //-----------------------------------------------------------------------------
 379 // Value operations: ValueResetImpl = set to default
 380 //-----------------------------------------------------------------------------
 381
 382 ValueResetImpl::ValueResetImpl()
 383 :ValueChangeImpl()
 384 , m_bTargetIsDefault(false)
 385 {
 386 }
 387 //-----------------------------------------------------------------------------
 388
 389 ValueResetImpl::ValueResetImpl(com::sun::star::uno::Any const& aNewValue, com::sun::star::uno::Any const& aOldValue)
 390 :ValueChangeImpl(aNewValue, aOldValue)
 391 , m_bTargetIsDefault(false)
 392 {
 393 }
 394 //-----------------------------------------------------------------------------
 395
 396 void ValueResetImpl::doApplyChange( ValueMemberUpdate& rNode)
 397 {
 398     rNode.setDefault();
 399 }
 400 //-----------------------------------------------------------------------------
 401
 402 bool ValueResetImpl::doIsChange() const
 403 {
 404     return !m_bTargetIsDefault;
 405 }
 406 //-----------------------------------------------------------------------------
 407
 408 bool ValueResetImpl::doFillChange( NodeChangeData& rChange, sal_uInt32 _ix) const
 409 {
 410     rChange.type = NodeChangeData::eSetDefault;
 411     ValueChangeImpl::doFillChange(rChange,_ix);
 412     return !m_bTargetIsDefault && !rChange.isEmptyChange(); // do it defensively here - default (= 'new') may be unknown still
 413 }
 414 //-----------------------------------------------------------------------------
 415
 416 void ValueResetImpl::preCheckValue(ValueMemberNode& rNode, com::sun::star::uno::Any& rOld, com::sun::star::uno::Any& rNew)
 417 {
 418     ValueChangeImpl::preCheckValue(rNode,rOld,rNew);
 419
 420     com::sun::star::uno::Any aDefaultValue = rNode.getDefaultValue();
 421     OSL_ENSURE(!rNew.hasValue() || rNew == aDefaultValue, "ERROR: Configuration: Stored new value of target does not match the actual default value");
 422     rNew = aDefaultValue;
 423     m_bTargetIsDefault = rNode.isDefault();
 424 }
 425
 426 //-----------------------------------------------------------------------------
 427 // All Set Changes: SetChangeImpl - common base
 428 //-----------------------------------------------------------------------------
 429
 430 SetChangeImpl::SetChangeImpl(bool bNoCheck)
 431 : NodeChangeImpl(bNoCheck)
 432 {
 433 }
 434 //-----------------------------------------------------------------------------
 435
 436 bool SetChangeImpl::doIsChangingSubnode() const
 437 {
 438     return false;
 439 }
 440
 441 //-----------------------------------------------------------------------------
 442 // Resetting a set to its default state
 443 //-----------------------------------------------------------------------------
 444
 445 SetResetImpl::SetResetImpl(
 446     SetElementFactory& _rElementFactory,
 447     std::auto_ptr<ISubtree> _pDefaultData,
 448     bool _bNoCheck
 449 )
 450 : SetChangeImpl(_bNoCheck)
 451 , m_aDefaultData(_pDefaultData)
 452 , m_rElementFactory(_rElementFactory)
 453 , m_aTreeChanges()
 454 {
 455 }
 456 //-----------------------------------------------------------------------------
 457
 458 SetResetImpl::~SetResetImpl()
 459 {
 460 }
 461 //-----------------------------------------------------------------------------
 462
 463 RelativePath SetResetImpl::doGetChangingNodePath(sal_uInt32 _ix) const
 464 {
 465     OSL_ENSURE( _ix < m_aTreeChanges.size() || _ix == scCommonBase, "Illegal Change index" );
 466     OSL_ASSERT( static_cast<size_t>(scCommonBase) > m_aTreeChanges.size() );
 467
 468     if ( _ix < m_aTreeChanges.size() )
 469         return RelativePath( m_aTreeChanges[_ix].m_aElementName);
 470
 471     else
 472         return RelativePath();
 473 }
 474 //-----------------------------------------------------------------------------
 475
 476 static NodeChangeData::Type getChangeType(ElementTreeChange const& aChange)
 477 {
 478     sal_Bool bHasNew = aChange.m_aAddedElement.is();
 479     sal_Bool bHasOld = aChange.m_aRemovedElement.is();
 480
 481     NodeChangeData::Type aResult;
 482      if (bHasNew)
 483         aResult = bHasOld ? NodeChangeData::eReplaceElement : NodeChangeData::eInsertElement;
 484     else
 485         aResult = bHasOld ? NodeChangeData::eRemoveElement : NodeChangeData::eSetDefault;
 486
 487     return aResult;
 488 }
 489 //-----------------------------------------------------------------------------
 490
 491 bool SetResetImpl::doIsChange() const
 492 {
 493     return !m_aTreeChanges.empty() || m_aDefaultData.get();
 494 }
 495 //-----------------------------------------------------------------------------
 496
 497 bool SetResetImpl::doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const
 498 {
 499     OSL_ENSURE( _ix < m_aTreeChanges.size() || _ix == scCommonBase, "Illegal Change index" );
 500     if (_ix >= m_aTreeChanges.size())
 501     {
 502         rChange.type = NodeChangeData::eResetSetDefault;
 503         return m_aDefaultData.get() != NULL;
 504     }
 505     ElementTreeChange const& aChange = m_aTreeChanges[_ix];
 506
 507     rChange.type = getChangeType(aChange);
 508
 509     rChange.element.newValue =  aChange.m_aAddedElement;
 510     rChange.element.oldValue =  aChange.m_aRemovedElement;
 511
 512     return true;
 513 }
 514 //-----------------------------------------------------------------------------
 515
 516 void SetResetImpl::doTest( view::Node const& rTarget)
 517 {
 518     if ( m_aDefaultData.get() )
 519     {
 520         view::ViewTreeAccess accessor = this->getTargetView();
 521
 522         view::SetNode aTargetSet(rTarget);
 523
 524         std::auto_ptr<SubtreeChange> pChanges = accessor.differenceToDefaultState(aTargetSet, *m_aDefaultData);
 525
 526         if (pChanges.get())
 527         {
 528             for (SubtreeChange::MutatingChildIterator   it = pChanges->begin_changes(),
 529                                                         stop = pChanges->end_changes();
 530                  it != stop;
 531                  ++it)
 532             {
 533                 rtl::OUString aName(it->getNodeName());
 534
 535                 SetEntry anExistingEntry = accessor.findElement(aTargetSet,aName);
 536
 537                 rtl::Reference<ElementTree> aOldTree = anExistingEntry.tree();
 538                 rtl::Reference<ElementTree> aNewTree;
 539
 540                 if (AddNode * addNode = dynamic_cast< AddNode * >(&*it))
 541                 {
 542                     rtl::Reference< data::TreeSegment > pAddedNode = addNode->getNewTree();
 543
 544                     OSL_ENSURE(pAddedNode.is(), "Processing an addNode to default - no node to add");
 545
 546                     aNewTree = m_rElementFactory.instantiateOnDefault(pAddedNode,accessor.getElementTemplate(aTargetSet)).get();
 547                 }
 548
 549
 550                 Path::Component aFullName =
 551                                     aNewTree.is() ? aNewTree->getExtendedRootName() :
 552                                     aOldTree.is() ? aOldTree->getExtendedRootName() :
 553                                     Path::makeCompositeName(aName,accessor.getElementTemplate(aTargetSet)->getName());
 554
 555                 OSL_ENSURE(aOldTree.is() || aNewTree.is(), "No data for change to default");
 556
 557                 m_aTreeChanges.push_back(ElementTreeChange(aFullName,aNewTree,aOldTree));
 558             }
 559         }
 560
 561         m_aDefaultData.reset();
 562     }
 563 }
 564 //-----------------------------------------------------------------------------
 565
 566 void SetResetImpl::doApply( view::Node const& rTarget)
 567 {
 568     view::ViewTreeAccess accessor = this->getTargetView();
 569
 570     view::SetNode aTargetSet(rTarget);
 571
 572     for (std::vector< ElementTreeChange >::iterator it = m_aTreeChanges.begin(); it != m_aTreeChanges.end(); ++it)
 573     {
 574         rtl::OUString aElementName = it->m_aElementName.getName();
 575
 576         if (it->m_aRemovedElement.is())
 577             accessor.removeElement(aTargetSet, aElementName);
 578
 579         if (it->m_aAddedElement.is())
 580         {
 581             SetEntry aNewEntry( it->m_aAddedElement.get() );
 582             accessor.insertElement(aTargetSet, aElementName, aNewEntry);
 583         }
 584
 585         OSL_ENSURE(getChangeType(*it) != NodeChangeData::eSetDefault,
 586                     "Cannot apply change without data");
 587     }
 588 }
 589
 590 //-----------------------------------------------------------------------------
 591 // All Set Changes affecting a single element: SetElementChangeImpl - common base
 592 //-----------------------------------------------------------------------------
 593
 594 SetElementChangeImpl::SetElementChangeImpl(Path::Component const& aName, bool bNoCheck)
 595 : SetChangeImpl(bNoCheck)
 596 , m_aName(aName)
 597 {
 598 }
 599 //-----------------------------------------------------------------------------
 600
 601 RelativePath SetElementChangeImpl::doGetChangingNodePath(sal_uInt32 ) const
 602 {
 603     return RelativePath(getFullElementName());
 604 }
 605 //-----------------------------------------------------------------------------
 606
 607 void SetElementChangeImpl::doTest( view::Node const& rTarget)
 608 {
 609     doTestElement(view::SetNode(rTarget), getElementName() );
 610 }
 611 //-----------------------------------------------------------------------------
 612
 613 void SetElementChangeImpl::doApply( view::Node const& rTarget)
 614 {
 615     doApplyToElement(view::SetNode(rTarget), getElementName() );
 616 }
 617
 618 //-----------------------------------------------------------------------------
 619 // Full Sets: SetInsertTreeImpl
 620 //-----------------------------------------------------------------------------
 621
 622 SetInsertImpl::SetInsertImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aNewTree, bool bNoCheck)
 623 : SetElementChangeImpl(aName,bNoCheck)
 624 , m_aNewTree(aNewTree)
 625 {
 626 }
 627 //-----------------------------------------------------------------------------
 628
 629 bool SetInsertImpl::doIsChange() const
 630 {
 631     return !!m_aNewTree.is();
 632 }
 633 //-----------------------------------------------------------------------------
 634
 635 bool SetInsertImpl::doFillChange(NodeChangeData& rChange, sal_uInt32) const
 636 {
 637     rChange.type = NodeChangeData::eInsertElement;
 638     if (m_aNewTree.is())
 639         rChange.element.newValue = m_aNewTree;
 640
 641     return isChange(true);
 642 }
 643 //-----------------------------------------------------------------------------
 644
 645 void SetInsertImpl::doTestElement( view::SetNode const& _aNode, rtl::OUString const& aName)
 646 {
 647     SetEntry anEntry = getTargetView().findElement(_aNode,aName); // require loaded children
 648     OSL_ENSURE(!anEntry.isValid(), "ERROR: Configuration: Adding a node that already exists");
 649 }
 650 //-----------------------------------------------------------------------------
 651
 652 void SetInsertImpl::doApplyToElement( view::SetNode const& _aNode, rtl::OUString const& aName)
 653 {
 654     if (m_aNewTree.is())
 655     {
 656         SetEntry aNewEntry( m_aNewTree.get() );
 657         getTargetView().insertElement( _aNode, aName, aNewEntry);
 658     }
 659 }
 660
 661 //-----------------------------------------------------------------------------
 662 // Full Sets: SetReplaceTreeImpl
 663 //-----------------------------------------------------------------------------
 664
 665 SetReplaceImpl::SetReplaceImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aNewTree)
 666 : SetElementChangeImpl(aName)
 667 , m_aNewTree(aNewTree)
 668 , m_aOldTree()
 669 {
 670 }
 671 //-----------------------------------------------------------------------------
 672
 673 SetReplaceImpl::SetReplaceImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aNewTree, rtl::Reference<ElementTree> const& aOldTree)
 674 : SetElementChangeImpl(aName,true)
 675 , m_aNewTree(aNewTree)
 676 , m_aOldTree(aOldTree)
 677 {
 678 }
 679 //-----------------------------------------------------------------------------
 680
 681 /// checks, if this represents an actual change
 682 bool SetReplaceImpl::doIsChange() const
 683 {
 684     return !(m_aOldTree == m_aNewTree);
 685 }
 686 //-----------------------------------------------------------------------------
 687
 688 /// fills in pre- and post-change values, returns wether they differ
 689 bool SetReplaceImpl::doFillChange(NodeChangeData& rChange, sal_uInt32) const
 690 {
 691     rChange.type = NodeChangeData::eReplaceElement;
 692     if (m_aNewTree.is())
 693         rChange.element.newValue =  m_aNewTree;
 694
 695     if (m_aOldTree.is())
 696         rChange.element.oldValue = m_aOldTree;
 697
 698     return isChange(true);
 699 }
 700 //-----------------------------------------------------------------------------
 701
 702 void SetReplaceImpl::doTestElement( view::SetNode const& _aNode, rtl::OUString const& aName)
 703 {
 704     OSL_ASSERT(!m_aOldTree.is()); // already tested ?
 705
 706     // remove the old node
 707     SetEntry anEntry = getTargetView().findElement(_aNode,aName); // require loaded children
 708     OSL_ENSURE(anEntry.isValid(), "ERROR: Configuration: Replacing a node that doesn't exist");
 709
 710     m_aOldTree = anEntry.tree();
 711 }
 712 //-----------------------------------------------------------------------------
 713
 714 void SetReplaceImpl::doApplyToElement( view::SetNode const& _aNode, rtl::OUString const& aName)
 715 {
 716     if (m_aOldTree != m_aNewTree)
 717     {
 718         view::ViewTreeAccess aTargetView = this->getTargetView();
 719
 720         OSL_ENSURE(m_aOldTree.is(), "ERROR: Configuration: Replacing a node that doesn't exist");
 721         aTargetView.removeElement(_aNode, aName);
 722
 723     // add the new one
 724         OSL_ENSURE(m_aNewTree.is(), "ERROR: Configuration: Replacing a node with nothing");
 725         if (m_aNewTree.is())
 726         {
 727             SetEntry aNewEntry( m_aNewTree.get() );
 728             aTargetView.insertElement( _aNode, aName, aNewEntry);
 729         }
 730     }
 731 }
 732
 733 //-----------------------------------------------------------------------------
 734 // Full Sets: SetRemoveTreeImpl
 735 //-----------------------------------------------------------------------------
 736
 737 SetRemoveImpl::SetRemoveImpl(Path::Component const& aName)
 738 : SetElementChangeImpl(aName)
 739 , m_aOldTree()
 740 {
 741 }
 742 //-----------------------------------------------------------------------------
 743
 744 SetRemoveImpl::SetRemoveImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aOldTree)
 745 : SetElementChangeImpl(aName,true)
 746 , m_aOldTree(aOldTree)
 747 {
 748 }
 749 //-----------------------------------------------------------------------------
 750
 751 /// checks, if this represents an actual change
 752 bool SetRemoveImpl::doIsChange() const
 753 {
 754     return !!m_aOldTree.is();
 755 }
 756 //-----------------------------------------------------------------------------
 757
 758 /// fills in pre- and post-change values, returns wether they differ
 759 bool SetRemoveImpl::doFillChange(NodeChangeData& rChange, sal_uInt32) const
 760 {
 761     rChange.type = NodeChangeData::eRemoveElement;
 762     if (m_aOldTree.is())
 763         rChange.element.oldValue = m_aOldTree;
 764
 765     return isChange(true);
 766 }
 767 //-----------------------------------------------------------------------------
 768
 769 void SetRemoveImpl::doTestElement( view::SetNode const& _aNode, rtl::OUString const& aName)
 770 {
 771     OSL_ASSERT(!m_aOldTree.is()); // already tested ?
 772
 773     // remove the old node
 774     SetEntry anEntry = getTargetView().findElement(_aNode,aName); // require loaded children
 775     OSL_ENSURE(anEntry.isValid(), "ERROR: Configuration: Removing a node that doesn't exist");
 776
 777     m_aOldTree = anEntry.tree();
 778 }
 779 //-----------------------------------------------------------------------------
 780
 781 void SetRemoveImpl::doApplyToElement( view::SetNode const& _aNode, rtl::OUString const& aName)
 782 {
 783     getTargetView().removeElement(_aNode, aName);
 784 }
 785
 786 //-----------------------------------------------------------------------------
 787     }
 788 }