configmgr/source/misc/mergechange.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: mergechange.cxx,v $
  10  * $Revision: 1.27 $
  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 "builddata.hxx"
  35 #include "mergechange.hxx"
  36 #include "updatehelper.hxx"
  37 #include "treeactions.hxx"
  38 #include "treefragment.hxx"
  39 #include "change.hxx"
  40 #include "treechangefactory.hxx"
  41 #include "treechangelist.hxx"
  42 #include "configexcept.hxx"
  43 #include "tracer.hxx"
  44
  45 #define ASCII(x) rtl::OUString::createFromAscii(x)
  46
  47 namespace configmgr
  48 {
  49     // -----------------------------------------------------------------------------
  50 // -----------------------------------------------------------------------------
  51
  52     // -----------------------------------------------------------------------------
  53     class OMergeChanges : private ChangeTreeAction, private OPathCreator<configuration::RelativePath>
  54     {
  55         SubtreeChange &m_rSubtreeChange;          // ChangeList, which will be grown
  56         SubtreeChange *m_pCurrentParent;                  // our current position
  57
  58         // ------- Helper for Path stack -------
  59         SubtreeChange* pushTree(SubtreeChange& _rTree);
  60         void popTree(SubtreeChange* _pSaveTree);
  61
  62     public:
  63         // CTor
  64         OMergeChanges(SubtreeChange& _rTree);
  65
  66         // start function, with the Change we want to do.
  67         // WARNING this could be a big tree, because a change can contain subtreechanges!
  68         void mergeChanges(const SubtreeChange &_rChange, const configuration::RelativePath& _aPathToChange);
  69         void mergeChanges(const SubtreeChange &_rChange);
  70
  71     private:
  72         void initRoot(const SubtreeChange &_rRootChange, const configuration::RelativePath& _aPathToChange);
  73     private:
  74         virtual void handle(ValueChange const& _rValueNode);
  75         virtual void handle(AddNode const& _rAddNode);
  76         virtual void handle(RemoveNode const& _rRemoveNode);
  77         virtual void handle(SubtreeChange const& _rSubtree);
  78
  79     };
  80     // -----------------------------------------------------------------------------
  81     void combineUpdates(SubtreeChange  const& _anUpdate, SubtreeChange& _aCombinedUpdate)
  82     {
  83         OMergeChanges aCombined(_aCombinedUpdate);
  84         aCombined.mergeChanges(_anUpdate);
  85     }
  86     // -----------------------------------------------------------------------------
  87
  88     configuration::Path::Component ONameCreator::createName(Change const& _rChange, SubtreeChange const* _pParent)
  89     {
  90         OSL_ENSURE(_pParent, "ONameCreator: Cannot create proper name without a parent");
  91         if (_pParent && _pParent->isSetNodeChange())
  92         {
  93             rtl::OUString sElementName = _rChange.getNodeName();
  94             rtl::OUString sTypeName = _pParent->getElementTemplateName();
  95
  96             return configuration::Path::makeCompositeName(sElementName, sTypeName);
  97         }
  98         else
  99         {
 100             rtl::OUString sElementName = _rChange.getNodeName();
 101
 102         //    OSL_ENSURE(isSimpleName(sElementName),"Unexpected: Non-simple name in non-set node");
 103
 104             return configuration::Path::wrapSafeName(sElementName);
 105         }
 106     }
 107
 108
 109     // -----------------------------------------------------------------------------
 110     class OMergeValueChange : private ChangeTreeModification
 111     {
 112         SubtreeChange&          m_rTargetParent;
 113         const ValueChange&      m_aValueChange;
 114     public:
 115         OMergeValueChange(SubtreeChange& _rTargetParent, const ValueChange& _aValueChange)
 116                 :m_rTargetParent(_rTargetParent)
 117                 ,m_aValueChange(_aValueChange)
 118         {
 119
 120         }
 121         void handleChange(Change &_rNode)
 122         {
 123             this->applyToChange(_rNode);
 124         }
 125     private:
 126         virtual void handle(ValueChange& _rValueChange)
 127         {
 128             // POST: Handle ValueChange
 129             _rValueChange.setNewValue(m_aValueChange.getNewValue(), m_aValueChange.getMode());
 130         }
 131               virtual void handle(RemoveNode& /*_rRemoveNode*/)
 132         {
 133             OSL_ENSURE(false, "OMergeValueChange::handle(ValueChange): have a ValueChange for a removed node!");
 134             // should never happen. How did the user change a value for a node which is obviously flagged as removed?
 135         }
 136         virtual void handle(AddNode& _rAddNode);
 137         virtual void handle(SubtreeChange& _rSubtree)
 138         {
 139             if ( isLocalizedValueSet(_rSubtree) )
 140             {
 141                 std::auto_ptr<ValueChange> pNewValueChange( new ValueChange(m_aValueChange) );
 142                 OSL_ENSURE(pNewValueChange->isLocalizedValue(), "OMergeValueChange:handle(SubtreeChange): have a non-localized ValueChange a for a localized node!");
 143
 144                 std::auto_ptr<Change> pNewChange( pNewValueChange.release() );
 145
 146                 replaceExistingEntry(pNewChange);
 147             }
 148             else
 149                 OSL_ENSURE(false, "OMergeValueChange:handle(SubtreeChange): have a ValueChange for a sub tree!");
 150         }
 151
 152         void replaceExistingEntry(std::auto_ptr<Change> pNewChange)
 153         {
 154             m_rTargetParent.removeChange(pNewChange->getNodeName());
 155             m_rTargetParent.addChange(pNewChange);
 156         }
 157         static std::auto_ptr<ValueNode> createNodeFromChange(ValueChange const& rChange)
 158         {
 159             std::auto_ptr<ValueNode> aRet;
 160
 161             uno::Any aNewValue = rChange.getNewValue();
 162
 163             // currently not supporting change modes !
 164             if (aNewValue.hasValue())
 165                 aRet.reset( new ValueNode(rChange.getNodeName(), aNewValue, rChange.getAttributes()) );
 166
 167             else  // NULL
 168             {
 169                 aRet.reset( new ValueNode(rChange.getNodeName(), rChange.getValueType(), rChange.getAttributes()) );
 170
 171                 OSL_ENSURE(aRet->isValid(), "Cannot recover type for change to NULL");
 172             }
 173             return aRet;
 174         }
 175
 176     };
 177
 178 // -----------------------------------------------------------------------------
 179 // -----------------------------------------------------------------------------
 180     // TODO: operate directly on new data structures
 181
 182     void OMergeValueChange::handle(AddNode& _rAddNode)
 183     {
 184         if (m_aValueChange.isToDefault())
 185         {
 186             std::auto_ptr<Change> aChangeToDefault(m_aValueChange.clone());
 187             m_rTargetParent.removeChange(_rAddNode.getNodeName());
 188             m_rTargetParent.addChange( aChangeToDefault );
 189         }
 190         else
 191         {
 192             // POST: Handle ValueChange in AddNode
 193             rtl::Reference< data::TreeSegment > seg(_rAddNode.getNewTree());
 194             std::auto_ptr<INode> pAddedNode = data::convertTree(seg.is() ? seg->fragment : 0, false);
 195
 196             if (ValueNode *pValueNode = pAddedNode->asValueNode())
 197             {
 198                 m_aValueChange.applyChangeNoRecover(*pValueNode);
 199             }
 200
 201             else if (ISubtree* pValueSetNode = pAddedNode->asISubtree() )
 202             {
 203                 if ( isLocalizedValueSet(*pValueSetNode) )
 204                 {
 205                     std::auto_ptr<ValueNode> pNewValueNode = createNodeFromChange(m_aValueChange);
 206                     if (pNewValueNode.get())
 207                     {
 208                         OSL_ENSURE(pNewValueNode->isLocalized(), "OMergeValueChange:handle(AddNode): have a non-localized ValueChange a for a localized node!");
 209                         pNewValueNode->setName(pAddedNode->getName());
 210                     }
 211                     else
 212                         OSL_ENSURE(false, "OMergeValueChange:handle(SubtreeChange): Creating a NULL node to replace a localized value set not yet supported");
 213
 214
 215                     pAddedNode.reset(pNewValueNode.release());
 216                 }
 217                 else
 218                 {
 219                     OSL_ENSURE(sal_False, "OMergeValueChange:handle(AddNode): have a ValueChange a for non-value node!");
 220                     pAddedNode.reset(); // leave unchanged
 221                 }
 222
 223             }
 224             else
 225             {
 226                 OSL_ENSURE(sal_False, "OMergeValueChange:handle(AddNode): Found unknown node type!");
 227                 pAddedNode.reset(); // leave unchanged
 228             }
 229
 230             if (pAddedNode.get() != NULL)
 231             {
 232                 rtl::Reference< data::TreeSegment > aNewTree = data::TreeSegment::create(_rAddNode.getNodeName(),pAddedNode);
 233
 234                 std::auto_ptr<AddNode> pNewAdd( new AddNode(aNewTree,m_aValueChange.getNodeName(), m_aValueChange.isToDefault()) );
 235                 if (_rAddNode.isReplacing())
 236                     pNewAdd->setReplacing();
 237
 238                 std::auto_ptr<Change> pNewChange( pNewAdd.release() );
 239                 replaceExistingEntry(pNewChange);
 240             }
 241         }
 242     }
 243 // -----------------------------------------------------------------------------
 244 // -----------------------------------------------------------------------------
 245     // -----------------------------------------------------------------------------
 246     class OMergeRemoveNode : private ChangeTreeModification
 247     {
 248     public:
 249         // actions to take with the remove node change
 250         enum Action
 251         {
 252             RemoveCompletely,
 253             FlagDeleted,
 254             Undetermined
 255         };
 256
 257     protected:
 258         Action  m_eAction;
 259
 260     public:
 261         OMergeRemoveNode() : m_eAction(Undetermined) {  }
 262
 263         Action getAction() const { return m_eAction; }
 264
 265         void handleChange(Change* _pChange)
 266             {
 267                 if (_pChange)
 268                     applyToChange(*_pChange);
 269                 else
 270                     // no change -> flag as deleted
 271                     m_eAction = FlagDeleted;
 272             }
 273
 274     private:
 275         virtual void handle(ValueChange& aValueChange)
 276             {
 277                 if (aValueChange.getAttributes().existsInDefault())
 278                     m_eAction = FlagDeleted;
 279                 else
 280                     m_eAction = RemoveCompletely;
 281             }
 282
 283               virtual void handle(RemoveNode& /*_rRemoveNode*/)
 284             {
 285                 OSL_ENSURE(false, "OMergeRemoveNode::handle(RemoveNode): should never happen!");
 286                 // how can a RemoveNode change exist if in the file we're merging it into
 287                 // there already is such a RemoveNode change (_rRemoveNode)?
 288             }
 289
 290         virtual void handle(AddNode& _rAddNode)
 291             {
 292                 if (_rAddNode.isReplacing())
 293                     m_eAction = FlagDeleted;
 294                 else
 295                     m_eAction = RemoveCompletely;
 296             }
 297
 298         virtual void handle(SubtreeChange& _rSubtree)
 299             {
 300                 if (_rSubtree.getAttributes().existsInDefault())
 301                     m_eAction = FlagDeleted;
 302                 else
 303                     m_eAction = RemoveCompletely;
 304             }
 305     };
 306     // -----------------------------------------------------------------------------
 307     // -----------------------------------------------------------------------------
 308
 309     static
 310     inline
 311     Change* findExistingChange(SubtreeChange* pCurrentParent, configuration::Path::Component const & _aName)
 312     {
 313         OSL_ASSERT(pCurrentParent);
 314
 315         Change *pChange = pCurrentParent->getChange(_aName.getName());
 316
 317         if (!pChange && !_aName.isSimpleName())
 318         {
 319             pChange = pCurrentParent->getChange(_aName.toPathString());
 320             OSL_ENSURE(!pChange, "Update trouble: Existing node found only by composite name while merging");
 321         }
 322
 323         return pChange;
 324     }
 325
 326     static
 327     inline
 328     Change* findExistingChange(SubtreeChange* pCurrentParent, rtl::OUString const & _aName)
 329     {
 330         OSL_ASSERT(pCurrentParent);
 331
 332         Change *pChange = pCurrentParent->getChange(_aName);
 333
 334         return pChange;
 335     }
 336     // -----------------------------------------------------------------------------
 337
 338     void adjustElementTemplate(SubtreeChange& _rChange, const rtl::OUString& _rName, const rtl::OUString& _rModule)
 339     {
 340         if (!_rChange.isSetNodeChange() || isGenericSetElementType(_rChange.getElementTemplateName()))
 341         {
 342             _rChange.setElementTemplate(_rName,_rModule);
 343         }
 344         else if ( isDummySetElementModule(_rChange.getElementTemplateModule()) &&
 345                  !isGenericSetElementType(_rName) && !isDummySetElementModule(_rModule))
 346         {
 347             OSL_ENSURE(_rChange.getElementTemplateName() == _rName,   "Adjusting: Template modules do not match");
 348
 349             _rChange.setElementTemplate(_rName,_rModule);
 350         }
 351         OSL_POSTCOND(_rChange.getElementTemplateName()   == _rName   || isGenericSetElementType(_rName),
 352                      "Adjusting: Template modules do not match");
 353         OSL_POSTCOND(_rChange.getElementTemplateModule() == _rModule || isDummySetElementModule(_rModule),
 354                      "Adjusting: Template modules do not match");
 355     }
 356     // -----------------------------------------------------------------------------
 357
 358     inline void adjustElementTemplate(SubtreeChange& _rChange, SubtreeChange const& _rSource)
 359     {
 360         if (_rSource.isSetNodeChange())
 361             adjustElementTemplate(_rChange, _rSource.getElementTemplateName(), _rSource.getElementTemplateModule());
 362     }
 363
 364     // -----------------------------------------------------------------------------
 365
 366     // CTor
 367     OMergeChanges::OMergeChanges(SubtreeChange& _rTree)
 368     : m_rSubtreeChange(_rTree), m_pCurrentParent(NULL)
 369     {
 370     }
 371     // -----------------------------------------------------------------------------
 372
 373     void OMergeChanges::initRoot(const SubtreeChange &_rRootChange, const configuration::RelativePath& _aPathToChange)
 374     {
 375         SubtreeChange* pCurrentParent = &m_rSubtreeChange;
 376
 377         if (!_aPathToChange.isEmpty())
 378         {
 379             OSL_PRECOND(_aPathToChange.getLocalName().getName() == _rRootChange.getNodeName(),
 380                             "Path to change root does not match change being merged" );
 381
 382             std::vector<configuration::Path::Component>::const_reverse_iterator const firstEnsure = _aPathToChange.begin();
 383             std::vector<configuration::Path::Component>::const_reverse_iterator lastEnsure = _aPathToChange.end();
 384             std::vector<configuration::Path::Component>::const_reverse_iterator it;
 385
 386             OSL_ASSERT( firstEnsure != lastEnsure );
 387             --lastEnsure; // last to ensure is the actual root
 388
 389             for( it = firstEnsure; it != lastEnsure; ++it)
 390             {
 391                 OSL_ASSERT( it != _aPathToChange.end() );
 392
 393                 Change *pChange = findExistingChange(pCurrentParent,*it);
 394
 395                 if (!pChange)
 396                 {
 397                     OSL_ASSERT( it+1 != _aPathToChange.end());
 398                     rtl::OUString const aElementTypeName = (it+1)->getTypeName();
 399
 400                     // create a correspondens for the name, we did not find.
 401                     std::auto_ptr<SubtreeChange> pNewChange =
 402                         OTreeChangeFactory::createDummyChange(it->getName(), aElementTypeName);
 403
 404                     pChange = pNewChange.get();
 405
 406                     pCurrentParent->addChange(base_ptr(pNewChange));
 407
 408                     OSL_ENSURE(pChange == findExistingChange(pCurrentParent,*it),
 409                                 "ERROR: Newly added change cannot be found in parent change");
 410                 }
 411
 412                 pCurrentParent = dynamic_cast<SubtreeChange*>( pChange);
 413                 if (pCurrentParent == 0)
 414                 {
 415                     OSL_ENSURE(false, "Change to merge does not point to a Subtree Change");
 416                     throw configuration::InvalidName(_aPathToChange.toString(), "points to a non- subtree change in this changes list, but a subtree change is required as root.");
 417                 }
 418             }
 419
 420             Change *pRootChange = findExistingChange(pCurrentParent,*lastEnsure);
 421
 422             if (!pRootChange)
 423             {
 424                 // create a correspondens for the name, we did not find.
 425                 std::auto_ptr<SubtreeChange> pNewChange(
 426                         new SubtreeChange(_rRootChange, treeop::NoChildCopy()) );
 427
 428                 pRootChange = pNewChange.get();
 429
 430                 pCurrentParent->addChange(base_ptr(pNewChange));
 431
 432                 OSL_ENSURE(pRootChange == findExistingChange(pCurrentParent,*it),
 433                             "ERROR: Newly added change cannot be found in parent change");
 434             }
 435
 436             pCurrentParent = dynamic_cast<SubtreeChange*>( pRootChange);
 437             if (pCurrentParent == 0)
 438             {
 439                 OSL_ENSURE(false, "Change to merge does not point to a Subtree Change");
 440                 throw configuration::InvalidName(_aPathToChange.toString(), "points to a non-subtree change in this changes list, but a subtree change is required as root.");
 441             }
 442         }
 443
 444         OSL_ENSURE(pCurrentParent->getNodeName() == _rRootChange.getNodeName(),
 445                         "Change being merged has a different name");
 446
 447         adjustElementTemplate(*pCurrentParent,_rRootChange);
 448
 449         this->init(_aPathToChange);
 450
 451         m_pCurrentParent = pCurrentParent;
 452     }
 453     // -----------------------------------------------------------------------------
 454
 455     // ------- Helper for Path stack -------
 456     SubtreeChange* OMergeChanges::pushTree(SubtreeChange& _rTree)
 457     {
 458         pushName( ONameCreator::createName(_rTree,m_pCurrentParent) );
 459
 460         SubtreeChange* pSave = m_pCurrentParent;
 461         m_pCurrentParent = &_rTree;
 462         return pSave;
 463     }
 464     void OMergeChanges::popTree(SubtreeChange* _pSaveTree)
 465     {
 466         m_pCurrentParent = _pSaveTree;
 467
 468         popName();
 469     }
 470     // -----------------------------------------------------------------------------
 471
 472     // start function, with the Change we want to do.
 473     // WARNING this could be a big tree, because a change can contain subtreechanges!
 474     void OMergeChanges::mergeChanges(const SubtreeChange &_rChange)
 475     {
 476         mergeChanges(_rChange, configuration::RelativePath());
 477     }
 478     // -----------------------------------------------------------------------------
 479
 480     // start function, with the Change we want to do.
 481     // WARNING this could be a big tree, because a change can contain subtreechanges!
 482     void OMergeChanges::mergeChanges(const SubtreeChange &_rChange, const configuration::RelativePath& _aPathToChange)
 483     {
 484         initRoot(_rChange, _aPathToChange); // path location being merged must exist
 485
 486         this->applyToChildren(_rChange); //- semantics ?
 487     }
 488     // -----------------------------------------------------------------------------
 489
 490     // Algorithm: search the actual path in the out m_aSubtreeChange
 491     // if we found something, we must merge/convert the Node with our Node
 492     // if we found nothing, we must create a new Node with our change
 493     // thats it.
 494
 495     // the merge is contructed with helper classes because, it's possible that we
 496     // are a ValueChange but in the TreeChangeList this change is an AddNode, so
 497     // we have something to do.
 498
 499     void OMergeChanges::handle(ValueChange const& _rValueNode)
 500     {
 501         // Handle a ValueChange,
 502         rtl::OUString aNodeName = _rValueNode.getNodeName();
 503
 504         if (Change *pChange = findExistingChange(m_pCurrentParent,aNodeName))
 505         {
 506             // Value found, merge content
 507             OMergeValueChange aMergeValue(*m_pCurrentParent,_rValueNode);
 508             aMergeValue.handleChange(*pChange);
 509         }
 510         else
 511         {
 512             // there is no ValueChange in the List, insert new one
 513             std::auto_ptr<Change> pNewChange(new ValueChange(_rValueNode));
 514             m_pCurrentParent->addChange(pNewChange);
 515         }
 516     }
 517     // -----------------------------------------------------------------------------
 518
 519     void OMergeChanges::handle(AddNode const& _rAddNode)
 520     {
 521         // Handle an AddNode
 522         bool bReplacing = _rAddNode.isReplacing();
 523
 524         rtl::OUString aNodeName = _rAddNode.getNodeName();
 525
 526         if (Change *pChange = findExistingChange(m_pCurrentParent,aNodeName))
 527         {
 528             OSL_ENSURE(dynamic_cast< RemoveNode * >(pChange) != 0 || bReplacing, "OMergeChanges::handle(AddNode): the changes tree given already contains a change for this!");
 529
 530             m_pCurrentParent->removeChange(pChange->getNodeName());
 531
 532             bReplacing = true;
 533         }
 534
 535         // insert manually
 536         rtl::Reference< data::TreeSegment > aAddedTree = data::TreeSegment::create(_rAddNode.getNewTree());
 537
 538         std::auto_ptr<AddNode> pNewAdd(new AddNode(aAddedTree, _rAddNode.getNodeName(), _rAddNode.isToDefault()));
 539         if (bReplacing)
 540             pNewAdd->setReplacing();
 541
 542         std::auto_ptr<Change> pNewChange( pNewAdd.release() );
 543         m_pCurrentParent->addChange(pNewChange);
 544     }
 545     // -----------------------------------------------------------------------------
 546
 547     void OMergeChanges::handle(RemoveNode const& _rRemoveNode)
 548     {
 549         // Handle a RemoveNode
 550         rtl::OUString aNodeName = _rRemoveNode.getNodeName();
 551
 552         Change *pChange = findExistingChange(m_pCurrentParent,aNodeName);
 553
 554         // examine what to do with this change
 555         OMergeRemoveNode aExaminer;
 556         aExaminer.handleChange(pChange);
 557
 558                 // remove the change from it's parent (may it's re-inserted in another form below)
 559         if (pChange)
 560             m_pCurrentParent->removeChange(pChange->getNodeName());
 561
 562         // insert a new change if necessary
 563         switch (aExaminer.getAction())
 564         {
 565         case OMergeRemoveNode::RemoveCompletely:
 566             // nothing to do, we already removed it
 567             break;
 568         default:
 569             OSL_ENSURE(sal_False, "OMergeChanges::handle(RemoveNode): don't know what to do with this!");
 570             // NO BREAK.
 571             // defaulting this so that the node will be marked as deleted
 572         case OMergeRemoveNode::FlagDeleted:
 573         {
 574             std::auto_ptr<Change> pNewChange(new RemoveNode(_rRemoveNode.getNodeName(),_rRemoveNode.isToDefault()));
 575             m_pCurrentParent->addChange(pNewChange);
 576         }
 577         break;
 578         }
 579     }
 580
 581 // -----------------------------------------------------------------------------
 582     inline
 583     void OStripDefaults::stripOne(Change& _rChange)
 584     {
 585         m_rParent.removeChange(_rChange.getNodeName());
 586     }
 587
 588     void OStripDefaults::handle(ValueChange& _rValueNode)
 589     {
 590         if (_rValueNode.isToDefault())
 591             stripOne(_rValueNode);
 592     }
 593     void OStripDefaults::handle(AddNode& _rAddNode)
 594     {
 595         if (_rAddNode.isToDefault())
 596         {
 597             sharable::TreeFragment const * pAdded = _rAddNode.getNewTreeData();
 598             OSL_ENSURE(pAdded,"No Data in AddNode");
 599             if (pAdded == NULL || pAdded->getAttributes().isDefault())
 600                 stripOne(_rAddNode);
 601
 602             // else we should strip the defaults from the added node
 603         }
 604     }
 605     void OStripDefaults::handle(RemoveNode& _rRemoveNode)
 606     {
 607         if (_rRemoveNode.isToDefault())
 608             stripOne(_rRemoveNode);
 609     }
 610     void OStripDefaults::handle(SubtreeChange& _rSubtree)
 611     {
 612         if ( strip(_rSubtree) )
 613             if (_rSubtree.isToDefault() || !_rSubtree.isSetNodeChange())
 614                 stripOne(_rSubtree);
 615     }
 616
 617     OStripDefaults& OStripDefaults::strip()
 618     {
 619         SubtreeChange::MutatingChildIterator it = m_rParent.begin_changes(), stop = m_rParent.end_changes();
 620
 621         while (it != stop)
 622         {
 623             this->applyToChange(*it++);
 624         }
 625
 626         return *this;
 627     }
 628
 629
 630 // -----------------------------------------------------------------------------
 631     class TreeUpdater : public ChangeTreeAction
 632     {
 633         ISubtree* m_pCurrentSubtree;
 634 #if OSL_DEBUG_LEVEL > 1
 635         std::vector<rtl::OString> aLog;
 636 #endif
 637
 638     public:
 639         TreeUpdater(ISubtree* pSubtree):m_pCurrentSubtree(pSubtree){}
 640
 641         void handle(ValueChange const& aValueNode);
 642         void handle(AddNode const& aAddNode);
 643         void handle(RemoveNode const& aRemoveNode);
 644         void handle(SubtreeChange const& aSubtree);
 645     };
 646
 647 // -----------------------------------------------------------------------------
 648
 649
 650     void OMergeChanges::handle(SubtreeChange const& _rSubtree)
 651     {
 652         // Handle a SubtreeChange
 653         // we must check if exact this SubtreeChange is in the TreeChangeList, if not,
 654         // we must add this SubtreeChange to the TreeChangeList
 655         // with the pointer m_pCurrentParent we remember our SubtreeChange in witch we
 656         // add all other Changes.
 657
 658         rtl::OUString aNodeName = _rSubtree.getNodeName();
 659
 660         Change *pChange = findExistingChange(m_pCurrentParent,aNodeName);
 661
 662         // const sal_Char* pType = pChange ? pChange->getType() : NULL;
 663         SubtreeChange* pSubtreeChange = NULL;
 664         if (pChange == NULL || dynamic_cast< SubtreeChange * >(pChange) != 0)
 665         {
 666             // need to create a new Subtreechange
 667             if (!pChange)
 668             {
 669                 // create a new SubtreeChange
 670                 std::auto_ptr<SubtreeChange> pNewChange(new SubtreeChange(_rSubtree, treeop::NoChildCopy()));
 671                 pSubtreeChange = pNewChange.get();
 672
 673                 // add the new SubtreeChange in m_aTreeChangeList
 674                 m_pCurrentParent->addChange(std::auto_ptr<Change>(pNewChange.release()));
 675                 // check list for this new SubtreeChange
 676                 OSL_ASSERT(pSubtreeChange == findExistingChange(m_pCurrentParent,aNodeName));
 677             }
 678             else
 679             {
 680                 pSubtreeChange = dynamic_cast<SubtreeChange*>(pChange);
 681                 OSL_ASSERT(pSubtreeChange != 0);
 682                 adjustElementTemplate(*pSubtreeChange,_rSubtree);
 683             }
 684
 685             // save this SubtreeChange so we allways have the last Subtree
 686             SubtreeChange* pSaveParent = pushTree(*pSubtreeChange);
 687             this->applyToChildren(_rSubtree);
 688             popTree( pSaveParent );
 689         }
 690         else if (AddNode* pAddNode = dynamic_cast<AddNode*>(pChange))
 691         {
 692             rtl::Reference< data::TreeSegment > seg(pAddNode->getNewTree());
 693             std::auto_ptr<INode> pAddedNode = data::convertTree(seg.is() ? seg->fragment : 0, false);
 694             ISubtree* pSubtree = pAddedNode.get() ? pAddedNode->asISubtree() : 0;
 695             if (pSubtree)
 696             {
 697                 pSubtree->markAsDefault( _rSubtree.isToDefault() );
 698
 699                 // Now apply _rSubtree to the subtree
 700                 TreeUpdater aTreeUpdate(pSubtree);
 701                 aTreeUpdate.applyToChildren(_rSubtree);
 702
 703                 // make a new subtree with the changed data
 704                 rtl::Reference< data::TreeSegment > aNewTree = data::TreeSegment::create(pAddNode->getNodeName(), pAddedNode);
 705
 706                 std::auto_ptr<AddNode> pNewAdd( new AddNode(aNewTree, pAddNode->getNodeName(), pAddNode->isToDefault()) );
 707                 if (pAddNode->isReplacing())
 708                     pNewAdd->setReplacing();
 709
 710                 std::auto_ptr<Change> pNewChange( pNewAdd.release() );
 711
 712                 m_pCurrentParent->removeChange(pAddNode->getNodeName());
 713                 m_pCurrentParent->addChange( pNewChange );
 714             }
 715             else
 716             {
 717                 OSL_ENSURE(false, "OMergeChanges: Unexpected node type found in an AddNode.");
 718                 /* wrong type of node found: böse ASSERTEN/WERFEN */;
 719             }
 720 // -----------------------------------------------------------------------------
 721 // -----------------------------------------------------------------------------
 722         }
 723         else
 724         {
 725             OSL_ENSURE(false, "OMergeChanges: Unexpected change type found for a subtree.");
 726             /* wrong type of node found: böse ASSERTEN/WERFEN */;
 727         }
 728     }
 729
 730     // --------------------------------- updateTree ---------------------------------
 731     void TreeUpdater::handle(ValueChange const& aValueNode)
 732     {
 733         // Change a Value
 734         OSL_ENSURE(m_pCurrentSubtree,"Cannot apply ValueChange without subtree");
 735
 736         INode* pBaseNode = m_pCurrentSubtree ? m_pCurrentSubtree->getChild(aValueNode.getNodeName()) : 0;
 737         OSL_ENSURE(pBaseNode,"Cannot apply Change: No node to change");
 738
 739         ValueNode* pValue = pBaseNode ? pBaseNode->asValueNode() : 0;
 740         OSL_ENSURE(pValue,"Cannot apply ValueChange: Node is not a value");
 741
 742         if (pValue)
 743             aValueNode.applyChangeNoRecover(*pValue);
 744 #if OSL_DEBUG_LEVEL > 1
 745         else
 746         {
 747             ::rtl::OString aStr("TreeUpdater: Can't find value with name:=");
 748             aStr += rtl::OUStringToOString(aValueNode.getNodeName(),RTL_TEXTENCODING_ASCII_US);
 749             OSL_ENSURE(pValue, aStr.getStr());
 750             aLog.push_back(aStr);
 751         }
 752 #endif
 753     }
 754
 755     void TreeUpdater::handle(AddNode const& aAddNode)
 756     {
 757         // Add a new Value
 758         if (m_pCurrentSubtree)
 759         {
 760             if (aAddNode.isReplacing())
 761             {
 762                 std::auto_ptr<INode> aOldNode = m_pCurrentSubtree->removeChild(aAddNode.getNodeName());
 763
 764 #if OSL_DEBUG_LEVEL > 1
 765                 OSL_ENSURE(aOldNode.get(), "TreeUpdater:AddNode: can't recover node being replaced");
 766                 if (aOldNode.get() == NULL)
 767                     aLog.push_back(rtl::OString("TreeUpdater: can't recover node being replaced (for AddNode)"));
 768 #endif
 769             }
 770
 771             rtl::Reference< data::TreeSegment > seg(aAddNode.getNewTree());
 772             std::auto_ptr<INode> pNode(data::convertTree(seg.is() ? seg->fragment : 0, true));
 773
 774             m_pCurrentSubtree->addChild(pNode);
 775         }
 776 #if OSL_DEBUG_LEVEL > 1
 777         else
 778             aLog.push_back(rtl::OString("TreeUpdater: no CurrentSubtree for AddNode"));
 779 #endif
 780
 781     }
 782
 783     void TreeUpdater::handle(RemoveNode const& aRemoveNode)
 784     {
 785         // remove a Value
 786         if (m_pCurrentSubtree)
 787         {
 788             std::auto_ptr<INode> aOldNode = m_pCurrentSubtree->removeChild(aRemoveNode.getNodeName());
 789
 790 #if OSL_DEBUG_LEVEL > 1
 791             if (NULL == aOldNode.get())
 792             {
 793                 ::rtl::OString aStr("TreeUpdater: Can't remove child with name:=");
 794                 aStr += rtl::OUStringToOString(aRemoveNode.getNodeName(),RTL_TEXTENCODING_ASCII_US);
 795                 OSL_ENSURE(false, aStr.getStr());
 796                 aLog.push_back(aStr);
 797             }
 798 #endif
 799         }
 800     }
 801
 802     void TreeUpdater::handle(SubtreeChange const& _aSubtree)
 803     {
 804         // handle traversion
 805         ISubtree *pOldSubtree = m_pCurrentSubtree;
 806         rtl::OUString aNodeName = _aSubtree.getNodeName();
 807
 808         INode* pChild = m_pCurrentSubtree->getChild(aNodeName);
 809         OSL_ENSURE(pChild, "TreeUpdater::handle : invalid subtree change ... no child for change !");
 810         m_pCurrentSubtree = pChild ? pChild->asISubtree() : NULL;
 811
 812 #if OSL_DEBUG_LEVEL > 1
 813         if (!m_pCurrentSubtree)
 814         {
 815             ::rtl::OString aStr("TreeUpdater: there is no Subtree for name:=");
 816             aStr += rtl::OUStringToOString(_aSubtree.getNodeName(),RTL_TEXTENCODING_ASCII_US);
 817             OSL_ENSURE(false, aStr.getStr());
 818             aLog.push_back(aStr);
 819         }
 820 #endif
 821         // recurse
 822         if (m_pCurrentSubtree)
 823         {
 824             m_pCurrentSubtree->markAsDefault( _aSubtree.isToDefault() );
 825             _aSubtree.forEachChange(*this);
 826         }
 827
 828         m_pCurrentSubtree = pOldSubtree;
 829     }
 830
 831 } // namespace configmgr