configmgr/source/treemgr/viewstrategy.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: viewstrategy.cxx,v $
  10  * $Revision: 1.13 $
  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 "viewstrategy.hxx"
  35 #include "valuenodeimpl.hxx"
  36 #include "groupnodeimpl.hxx"
  37 #include "setnodeimpl.hxx"
  38 #include "change.hxx"
  39 #include "nodevisitor.hxx"
  40 #include "nodechange.hxx"
  41 #include "nodechangeimpl.hxx"
  42 #include "nodeconverter.hxx"
  43 //-----------------------------------------------------------------------------
  44 namespace configmgr
  45 {
  46 //-----------------------------------------------------------------------------
  47     namespace view
  48     {
  49 //-----------------------------------------------------------------------------
  50         static
  51         inline
  52         sharable::ValueNode * getMemberValueAccess( GroupNode const & _aGroupNode, rtl::OUString const & _aName )
  53         {
  54             configuration::GroupNodeImpl* pGroupData = _aGroupNode.get_impl();
  55             return pGroupData->getOriginalValueNode(_aName);
  56         }
  57
  58 //-----------------------------------------------------------------------------
  59         void ViewStrategy::checkInstance(configuration::Tree * tree) const
  60         {
  61             (void) tree; // avoid warnings
  62             OSL_ENSURE( getViewBehavior(tree).get() == this,
  63                         "Tree operation dispatched to wrong strategy instance");
  64         }
  65 //-----------------------------------------------------------------------------
  66         void ViewStrategy::collectChanges(configuration::Tree * tree, configuration::NodeChanges& rChanges)     const
  67         {
  68             checkInstance(tree);
  69             doCollectChanges( getRootNode(tree), rChanges );
  70         }
  71
  72         bool ViewStrategy::hasChanges(configuration::Tree * tree) const
  73         {
  74             checkInstance(tree);
  75             return hasChanges( getRootNode(tree) );
  76         }
  77
  78         // mark the given node and all its ancestors (we can stop when we hit a node that already is marked)
  79         void ViewStrategy::markChanged(Node const& _aNode)
  80         {
  81             configuration::Tree * tree = _aNode.tree();
  82             checkInstance(tree);
  83
  84             Node aNode = _aNode;
  85             if (aNode.is())
  86             {
  87                 do
  88                 {
  89                     this->doMarkChanged(aNode);
  90
  91                     aNode = aNode.getParent();
  92                 }
  93                 while (aNode.is() && !this->hasChanges( aNode ));
  94             }
  95
  96             if (!aNode.is()) // just marked the root
  97             {
  98                 configuration::Tree* pContext = tree->getContextTree();
  99                 unsigned int nContext = tree->getContextNode();
 100                 if (pContext)
 101                 {
 102                     OSL_ASSERT(pContext->isValidNode(nContext));
 103
 104                     view::Node aContextNode(pContext,nContext);
 105                     pContext->getViewBehavior()->markChanged(aContextNode);
 106                 }
 107             }
 108         }
 109
 110 //-----------------------------------------------------------------------------
 111         std::auto_ptr<SubtreeChange> ViewStrategy::preCommitChanges(configuration::Tree * tree, std::vector< rtl::Reference<configuration::ElementTree> >& _rRemovedElements)
 112         {
 113             checkInstance(tree);
 114             return doPreCommitChanges( tree, _rRemovedElements);
 115         }
 116
 117         void ViewStrategy::finishCommit(configuration::Tree * tree, SubtreeChange& rRootChange)
 118         {
 119             checkInstance(tree);
 120             doFinishCommit(tree, rRootChange);
 121         }
 122
 123         void ViewStrategy::revertCommit(configuration::Tree * tree, SubtreeChange& rRootChange)
 124         {
 125             checkInstance(tree);
 126             doRevertCommit(tree, rRootChange);
 127         }
 128
 129         void ViewStrategy::recoverFailedCommit(configuration::Tree * tree, SubtreeChange& rRootChange)
 130         {
 131             checkInstance(tree);
 132             doFailedCommit(tree, rRootChange);
 133         }
 134
 135 //-----------------------------------------------------------------------------
 136         void ViewStrategy::adjustToChanges(configuration::NodeChangesInformation& rLocalChanges, Node const& _aNode, SubtreeChange const& aExternalChange)
 137         {
 138             OSL_PRECOND( isValidNode(_aNode), "ERROR: Valid node required for adjusting to changes" );
 139             OSL_PRECOND( getSimpleNodeName(_aNode) == aExternalChange.getNodeName(), "name of change does not match actual node" );
 140
 141             checkInstance(_aNode.tree());
 142
 143             configuration::Tree * pTreeData = _aNode.tree();
 144
 145             if (_aNode.isSetNode())
 146             {
 147                 OSL_ENSURE(aExternalChange.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
 148
 149                    unsigned int nDepth = pTreeData->getRemainingDepth(_aNode.get_offset());
 150
 151                 implAdjustToElementChanges( rLocalChanges, SetNode(_aNode), aExternalChange, nDepth);
 152             }
 153             else if (_aNode.isGroupNode())
 154             {
 155                 OSL_ENSURE(!aExternalChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
 156
 157                 GroupNode aGroupNode(_aNode);
 158
 159                 implAdjustToValueChanges(rLocalChanges, aGroupNode, aExternalChange);
 160                 implAdjustToSubChanges(  rLocalChanges, aGroupNode, aExternalChange);
 161             }
 162             else // might occur on external change (?)
 163             {
 164                 OSL_ENSURE(_aNode.isValueNode(), "Tree: Unknown node type to adjust to changes");
 165
 166                 OSL_ENSURE(_aNode.get_offset() == configuration::Tree::ROOT, "Tree: Unexpected node type - non-root value element");
 167
 168                 OSL_ENSURE(false,"ERROR: Change type does not match node: Trying to apply subtree change to value element.");
 169             }
 170         }
 171
 172 //-----------------------------------------------------------------------------
 173
 174         void ViewStrategy::addLocalChangeHelper( configuration::NodeChangesInformation& rLocalChanges_, configuration::NodeChange const& aChange_)
 175         {
 176             aChange_.getChangeInfos(rLocalChanges_);
 177         }
 178
 179 //-----------------------------------------------------------------------------
 180         // TO DO: create CommitAction class, which is returned by precommit (if applicable)
 181
 182         std::auto_ptr<SubtreeChange> ViewStrategy::doPreCommitChanges(configuration::Tree * tree, std::vector< rtl::Reference<configuration::ElementTree> >& )
 183         {
 184             (void) tree; // avoid warnings
 185             OSL_ENSURE(!hasChanges(getRootNode(tree)),"Unexpected changes in View");
 186             return std::auto_ptr<SubtreeChange>();
 187         }
 188
 189         void ViewStrategy::doFinishCommit(configuration::Tree * tree, SubtreeChange& )
 190         {
 191             (void) tree; // avoid warnings
 192             OSL_ENSURE(!hasChanges(getRootNode(tree)),"Unexpected changes in View");
 193             OSL_ENSURE(false,"ERROR: Cannot finish commit for unexpected changes");
 194         }
 195
 196         void ViewStrategy::doRevertCommit(configuration::Tree * tree, SubtreeChange& )
 197         {
 198             (void) tree; // avoid warnings
 199             OSL_ENSURE(!hasChanges(getRootNode(tree)),"Unexpected changes in View");
 200             OSL_ENSURE(false,"ERROR: Cannot revert commit for unexpected changes");
 201         }
 202
 203         void ViewStrategy::doFailedCommit(configuration::Tree * tree, SubtreeChange& )
 204         {
 205             (void) tree; // avoid warnings
 206             OSL_ENSURE(!hasChanges(getRootNode(tree)),"Unexpected changes in View");
 207             OSL_ENSURE(false,"ERROR: Cannot recover commit for unexpected changes");
 208         }
 209
 210 //-----------------------------------------------------------------------------
 211         void ViewStrategy::implAdjustToElementChange(configuration::NodeChangesInformation& rLocalChanges, SetNode const& _aSetNode, Change const& rElementChange, unsigned int nDepth)
 212         {
 213             configuration::SetNodeImpl * pSetData = _aSetNode.get_impl();
 214
 215             OSL_ENSURE( pSetData->implHasLoadedElements() , "Unexpected call: Processing element change in uninitialized set");
 216
 217             rtl::OUString aName( rElementChange.getNodeName() );
 218
 219             configuration::SetElementChangeImpl* pThisChange = 0;
 220             if (AddNode const * addNode = dynamic_cast< AddNode const *>(&rElementChange))
 221             {
 222                 configuration::ElementTreeData aNewElement = pSetData->makeAdditionalElement(this, *addNode, nDepth);
 223
 224                 pThisChange = pSetData->doAdjustToAddedElement(aName, *addNode, aNewElement);
 225             }
 226             else if (RemoveNode const * removeNode = dynamic_cast< RemoveNode const * >(&rElementChange))
 227             {
 228                 pThisChange = pSetData->doAdjustToRemovedElement(aName, *removeNode);
 229             }
 230             else
 231             {
 232                 if (nDepth > 0 || (NULL != pSetData->doFindElement(aName)) )// found even beyond nDepth ?
 233                 {
 234                     pThisChange = pSetData->doAdjustChangedElement(rLocalChanges,aName, rElementChange);
 235                 }
 236             }
 237
 238             if (pThisChange)
 239             {
 240                 addLocalChangeHelper( rLocalChanges, configuration::NodeChange(pThisChange) );
 241             }
 242         }
 243
 244         void ViewStrategy::implAdjustToElementChanges(configuration::NodeChangesInformation& rLocalChanges, SetNode const& _aSetNode, SubtreeChange const& rExternalChanges, unsigned int nDepth)
 245         {
 246
 247             if (nDepth > 0)
 248             {
 249                 configuration::SetNodeImpl * pSetData = _aSetNode.get_impl();
 250
 251                 OSL_ENSURE( pSetData->getTemplateProvider().isValid(), "Cannot adjust SetNode to changes - node was never initialized" );
 252
 253                 if (pSetData->implHasLoadedElements())
 254                 {
 255                     unsigned int const nElementDepth = configuration::childDepth(nDepth);
 256                     for (SubtreeChange::ChildIterator it = rExternalChanges.begin(); it != rExternalChanges.end(); ++it)
 257                     {
 258                         this->implAdjustToElementChange(rLocalChanges, _aSetNode, *it, nElementDepth);
 259                     }
 260                 }
 261                 else
 262                 {
 263                     OSL_ENSURE( !hasChanges(_aSetNode.node()),"Cannot have changes to consider when no elements are loaded");
 264
 265                     pSetData->convertChanges( rLocalChanges, rExternalChanges, nDepth);
 266                 }
 267             }
 268         }
 269
 270         configuration::ValueChangeImpl* ViewStrategy::doAdjustToValueChange(GroupNode const& _aGroupNode, rtl::OUString const& _aName, ValueChange const& _rExternalChange)
 271         {
 272             configuration::ValueChangeImpl* pChangeImpl = NULL;
 273
 274             sharable::ValueNode * localNode = getMemberValueAccess(_aGroupNode,_aName);
 275             if (localNode != 0)
 276             {
 277                 switch( _rExternalChange. getMode() )
 278                 {
 279                 case ValueChange::wasDefault:
 280                 case ValueChange::changeValue:
 281                     pChangeImpl = new configuration::ValueReplaceImpl( _rExternalChange.getNewValue(), _rExternalChange.getOldValue() );
 282                     break;
 283
 284                 case ValueChange::setToDefault:
 285                     pChangeImpl = new configuration::ValueResetImpl( _rExternalChange.getNewValue(), _rExternalChange.getOldValue() );
 286                     break;
 287
 288                 default: OSL_ENSURE(false, "Unknown change mode");
 289                     // fall thru to next case for somewhat meaningful return value
 290                 case ValueChange::changeDefault:
 291                     {
 292                         com::sun::star::uno::Any aLocalValue = localNode->getValue();
 293
 294                         pChangeImpl = new configuration::ValueReplaceImpl( aLocalValue, aLocalValue );
 295                     }
 296                     break;
 297                 }
 298                 OSL_ASSERT( pChangeImpl );
 299             }
 300             else
 301             {
 302                 OSL_ENSURE(false, "ERROR: Notification tries to change nonexistent value within group");
 303             }
 304
 305             return pChangeImpl;
 306         }
 307
 308         void ViewStrategy::implAdjustToValueChanges(configuration::NodeChangesInformation& rLocalChanges, GroupNode const& _aGroupNode, SubtreeChange const& rExternalChanges)
 309         {
 310             for (SubtreeChange::ChildIterator it = rExternalChanges.begin(); it != rExternalChanges.end(); ++it)
 311             {
 312                 if (ValueChange const * valueChange = dynamic_cast< ValueChange const * >(&*it))
 313                 {
 314                     rtl::OUString aValueName( valueChange->getNodeName() );
 315
 316                     if (configuration::ValueChangeImpl* pThisChange = doAdjustToValueChange(_aGroupNode, aValueName, *valueChange))
 317                     {
 318                         pThisChange->setTarget(_aGroupNode,aValueName);
 319                         addLocalChangeHelper(rLocalChanges, configuration::NodeChange(pThisChange));
 320                     }
 321                     else
 322                         OSL_TRACE("WARNING: Configuration: derived class hides an external value member change from listeners");
 323                 }
 324                 else
 325                     OSL_ENSURE(dynamic_cast< SubtreeChange const * >(&*it) != 0, "Unexpected change type within group");
 326             }
 327         }
 328
 329         void ViewStrategy::implAdjustToSubChanges(configuration::NodeChangesInformation& rLocalChanges, GroupNode const& _aGroupNode, SubtreeChange const& rExternalChanges)
 330         {
 331 #if (OSL_DEBUG_LEVEL > 0)
 332             configuration::Tree * pTreeData = _aGroupNode.tree();
 333 #endif
 334             for(SubtreeChange::ChildIterator it = rExternalChanges.begin(); it != rExternalChanges.end(); ++it)
 335             {
 336                 if (SubtreeChange const * subtreeChange = dynamic_cast< SubtreeChange const * >(&*it))
 337                 {
 338                     Node aSubNode = _aGroupNode.findChild( it->getNodeName() );
 339                     OSL_ENSURE( aSubNode.is() || pTreeData->depthTo(_aGroupNode.node().get_offset()) >= pTreeData->getAvailableDepth(), "Changed node not found in tree");
 340
 341                     if (aSubNode.is())
 342                     {
 343                         OSL_ENSURE( pTreeData->getRemainingDepth(_aGroupNode.node().get_offset()) > 0, "Depth is smaller than expected for tree");
 344                         this->adjustToChanges(rLocalChanges, aSubNode, *subtreeChange);
 345                     }
 346                 }
 347                 else
 348                 {
 349                     OSL_ENSURE(dynamic_cast< ValueChange const * >(&*it) != 0, "Unexpected change type for child of group node; change is ignored");
 350                     OSL_ENSURE( !_aGroupNode.findChild(it->getNodeName()).is(),
 351                                 "Found sub(tree) node where a value was expected");
 352                 }
 353             }
 354         }
 355 //-----------------------------------------------------------------------------
 356         void ViewStrategy::doCollectChanges(Node const& _aNode, configuration::NodeChanges& ) const
 357         {
 358             { (void)_aNode; }
 359             // no-op: there are no changes to collect
 360             OSL_ENSURE(!hasChanges(_aNode),"Unexpected changes in View");
 361         }
 362
 363
 364 //-----------------------------------------------------------------------------
 365         com::sun::star::uno::Any        ViewStrategy::getValue(ValueNode const& _aNode) const
 366         {
 367             checkInstance(_aNode.tree());
 368             return _aNode.get_impl()->getValue();
 369         }
 370 #if OSL_DEBUG_LEVEL > 0
 371         com::sun::star::uno::Type ViewStrategy::getValueType(ValueNode const& _aNode)   const
 372         {
 373             checkInstance(_aNode.tree());
 374             return _aNode.get_impl()->getValueType();
 375         }
 376 #endif
 377 //-----------------------------------------------------------------------------
 378 // group member access
 379
 380 //-----------------------------------------------------------------------------
 381     namespace { // helpers
 382         struct GroupMemberDispatch : data::NodeVisitor
 383         {
 384             GroupMemberDispatch(ViewStrategy& _rStrategy, GroupNode const& _aGroup, configuration::GroupMemberVisitor& rVisitor)
 385             : m_rStrategy(_rStrategy)
 386             , m_aGroup(_aGroup)
 387             , m_rVisitor(rVisitor)
 388             {}
 389
 390             static bool mapResult(configuration::GroupMemberVisitor::Result _aResult)
 391             {
 392                 return _aResult == configuration::GroupMemberVisitor::DONE;
 393             }
 394
 395             static configuration::GroupMemberVisitor::Result unmapResult(bool done)
 396             {
 397                 return done
 398                     ? configuration::GroupMemberVisitor::DONE
 399                     : configuration::GroupMemberVisitor::CONTINUE;
 400             }
 401
 402             using NodeVisitor::handle;
 403             virtual bool handle(sharable::Node * node);
 404             virtual bool handle(sharable::ValueNode * node);
 405 #if (OSL_DEBUG_LEVEL > 0)
 406             bool test_value(sharable::Node * node) const;
 407 #endif
 408             ViewStrategy&       m_rStrategy;
 409             GroupNode           m_aGroup;
 410             configuration::GroupMemberVisitor& m_rVisitor;
 411
 412             configuration::GroupMemberVisitor::Result m_aResult;
 413         };
 414
 415 #if (OSL_DEBUG_LEVEL > 0)
 416         bool GroupMemberDispatch::test_value(sharable::Node * node) const
 417         {
 418             return m_rStrategy.hasValue(m_aGroup, node->getName());
 419         }
 420 #endif
 421
 422         bool GroupMemberDispatch::handle(sharable::ValueNode * node)
 423         {
 424             OSL_ENSURE( test_value(sharable::node(node)), "ERROR: Group MemberDispatch:Did not find a ValueMember for a value child.");
 425
 426             rtl::OUString aValueName = node->info.getName();
 427
 428             return mapResult( m_rVisitor.visit( m_rStrategy.getValue(m_aGroup,aValueName) ) );
 429         }
 430
 431         bool GroupMemberDispatch::handle(sharable::Node * node)
 432         {
 433             (void) node; // avoid warnings
 434             OSL_ENSURE( !test_value(node), "ERROR: Group MemberDispatch:Found a ValueMember for a subtree child.");
 435
 436             return false;
 437         }
 438     }
 439 //-----------------------------------------------------------------------------
 440         configuration::ValueMemberNode ViewStrategy::doGetValueMember(GroupNode const& _aNode, rtl::OUString const& _aName, bool ) const
 441         {
 442             sharable::ValueNode * valueData = getMemberValueAccess(_aNode,_aName);
 443             return _aNode.get_impl()->makeValueMember(valueData);
 444         }
 445
 446         bool ViewStrategy::hasValue(GroupNode const& _aNode, rtl::OUString const& _aName) const
 447         {
 448             checkInstance(_aNode.tree());
 449             return getMemberValueAccess(_aNode,_aName) != 0;
 450         }
 451
 452         bool ViewStrategy::hasValue(GroupNode const& _aNode) const
 453         {
 454             checkInstance(_aNode.tree());
 455             configuration::GroupNodeImpl* pGroupNode=_aNode.get_impl();
 456             sharable::GroupNode * group = pGroupNode->getDataAccess();
 457             return group->numDescendants > 0;
 458         }
 459
 460
 461         bool ViewStrategy::areValueDefaultsAvailable(GroupNode const& _aNode) const
 462         {
 463             checkInstance(_aNode.tree());
 464
 465             return  _aNode.get_impl()->areValueDefaultsAvailable();
 466         }
 467
 468         configuration::ValueMemberNode ViewStrategy::getValue(GroupNode const& _aNode, rtl::OUString const& _aName) const
 469         {
 470             checkInstance(_aNode.tree());
 471             return doGetValueMember(_aNode,_aName,false);
 472         }
 473
 474         configuration::ValueMemberUpdate ViewStrategy::getValueForUpdate(GroupNode const & _aNode, rtl::OUString const& _aName)
 475         {
 476             checkInstance(_aNode.tree());
 477             return configuration::ValueMemberUpdate( doGetValueMember(_aNode,_aName,true), *this );
 478         }
 479
 480         configuration::GroupMemberVisitor::Result ViewStrategy::dispatchToValues(GroupNode const& _aNode, configuration::GroupMemberVisitor& _aVisitor)
 481         {
 482             checkInstance(_aNode.tree());
 483
 484             GroupMemberDispatch aDispatch(*this,_aNode,_aVisitor);
 485
 486             bool done = aDispatch.visitChildren( _aNode.getAccess() );
 487
 488             return aDispatch.unmapResult(done);
 489         }
 490
 491 //-----------------------------------------------------------------------------
 492         configuration::ElementTreeData ViewStrategy::implMakeElement(SetNode const& _aNode, configuration::SetEntry const& anEntry) const
 493         {
 494             configuration::SetNodeImpl * pNodeData = _aNode.get_impl();
 495             return pNodeData->implValidateElement(pNodeData->entryToElement(anEntry));
 496         }
 497 //-----------------------------------------------------------------------------
 498         configuration::SetEntry ViewStrategy::implFindElement(SetNode const& _aNode, rtl::OUString const& aName) const
 499         {
 500             configuration::SetNodeImpl * pNodeData = _aNode.get_impl();
 501
 502             OSL_ENSURE(pNodeData->implHasLoadedElements(),"Cannot find elements in set that is not loaded");
 503             configuration::ElementTree * pElement = pNodeData->doFindElement(aName);
 504
 505             return configuration::SetEntry(pElement);
 506         }
 507
 508         configuration::SetEntry ViewStrategy::findElement(SetNode const& _aNode, rtl::OUString const& aName) const
 509         {
 510             checkInstance(_aNode.tree());
 511             _aNode.get_impl()->implEnsureElementsLoaded();
 512             return implFindElement(_aNode,aName);
 513         }
 514
 515         configuration::SetEntry ViewStrategy::findAvailableElement(SetNode const& _aNode, rtl::OUString const& aName) const
 516         {
 517             checkInstance(_aNode.tree());
 518             if (_aNode.get_impl()->implHasLoadedElements())
 519                 return implFindElement(_aNode,aName);
 520             else
 521                 return configuration::SetEntry(0);
 522         }
 523
 524         static
 525         inline
 526         std::auto_ptr<SubtreeChange> makeChangeToDefault(sharable::SetNode * setNode)
 527         {
 528             return std::auto_ptr<SubtreeChange>(
 529                         new SubtreeChange(
 530                             setNode->info.getName(),
 531                             setNode->getElementTemplateName(),
 532                             setNode->getElementTemplateModule(),
 533                             sharable::node(setNode)->getAttributes(),
 534                             true // to default
 535                    )    );
 536         }
 537
 538         std::auto_ptr<SubtreeChange> ViewStrategy::differenceToDefaultState(SetNode const& _aNode, ISubtree& _rDefaultTree) const
 539         {
 540             checkInstance(_aNode.tree());
 541             std::auto_ptr<SubtreeChange> aResult;
 542
 543             sharable::SetNode * originalSetNode = _aNode.getAccess();
 544             OSL_ASSERT(originalSetNode != 0);
 545             if (!originalSetNode->info.isDefault())
 546             {
 547                 aResult = makeChangeToDefault(originalSetNode);
 548
 549                 configuration::SetNodeImpl * pNodeData = _aNode.get_impl();
 550                 if (this->hasChanges(_aNode.node()))
 551                 {
 552                     OSL_ENSURE(pNodeData->implHasLoadedElements(),"Unexpected: Found set with changes but elements are not loaded");
 553                     pNodeData->doDifferenceToDefaultState(*aResult,_rDefaultTree);
 554                 }
 555                 else
 556                     pNodeData->implDifferenceToDefaultState(*aResult,_rDefaultTree);
 557             }
 558             return aResult;
 559         }
 560
 561         rtl::Reference<configuration::Template> ViewStrategy::getElementTemplate(SetNode const& _aNode) const
 562         {
 563             checkInstance(_aNode.tree());
 564             return _aNode.get_impl()->getElementTemplate();
 565         }
 566
 567         configuration::TemplateProvider ViewStrategy::getTemplateProvider(SetNode const& _aNode) const
 568         {
 569             checkInstance(_aNode.tree());
 570             return _aNode.get_impl()->getTemplateProvider();
 571         }
 572
 573         node::Attributes ViewStrategy::getNodeAttributes(Node const& _aNode) const
 574         {
 575             checkInstance(_aNode.tree());
 576             return _aNode.getAccessRef()->getAttributes();
 577         }
 578
 579 //-----------------------------------------------------------------------------
 580         configuration::SetNodeVisitor::Result ViewStrategy::dispatchToElements(SetNode const& _aNode, configuration::SetNodeVisitor& _aVisitor)
 581         {
 582             checkInstance(_aNode.tree());
 583
 584             configuration::SetNodeImpl * pNodeData = _aNode.get_impl();
 585
 586             if (pNodeData->implLoadElements())
 587                 return pNodeData->doDispatchToElements(_aVisitor);
 588
 589             else
 590                 return configuration::SetNodeVisitor::CONTINUE;
 591         }
 592
 593         bool ViewStrategy::isEmpty(SetNode const& _aNode) const
 594         {
 595             checkInstance(_aNode.tree());
 596
 597             configuration::SetNodeImpl * pNodeData = _aNode.get_impl();
 598
 599             return !pNodeData->implLoadElements() || pNodeData->doIsEmpty();
 600         }
 601 //-----------------------------------------------------------------------------
 602
 603         void ViewStrategy::insertElement(SetNode const& _aNode, rtl::OUString const& _aName, configuration::SetEntry const& _aNewEntry)
 604         {
 605             // cannot insert, if we cannot check for collisions
 606             checkInstance(_aNode.tree());
 607             _aNode.get_impl()->implEnsureElementsLoaded();
 608             doInsertElement(_aNode,_aName,_aNewEntry);
 609         }
 610
 611         void ViewStrategy::removeElement(SetNode const& _aNode, rtl::OUString const& _aName)
 612         {
 613             // cannot remove, if we cannot check for existance
 614             checkInstance(_aNode.tree());
 615             _aNode.get_impl()->implEnsureElementsLoaded();
 616             doRemoveElement(_aNode,_aName);
 617         }
 618
 619 //-----------------------------------------------------------------------------
 620     }
 621 //-----------------------------------------------------------------------------
 622 }
 623