configmgr/source/treemgr/setnodeimpl.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: setnodeimpl.cxx,v $
  10  * $Revision: 1.26 $
  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 #include <stdio.h>
  34
  35 #include "builddata.hxx"
  36 #include "setnodeimpl.hxx"
  37 #include "treefragment.hxx"
  38 #include "viewfactory.hxx"
  39 #include "configpath.hxx"
  40 #include "tree.hxx"
  41 #include "valuenodeimpl.hxx"
  42 #include "nodechange.hxx"
  43 #include "nodechangeimpl.hxx"
  44 #include "nodevisitor.hxx"
  45 #include "change.hxx"
  46 #include "viewaccess.hxx"
  47 #include "nodeconverter.hxx"
  48 #include "treeactions.hxx"
  49 #include "treechangefactory.hxx"
  50 #include "collectchanges.hxx"
  51 #include <osl/diagnose.h>
  52
  53 #ifndef INCLUDED_VECTOR
  54 #include <vector>
  55 #define INCLUDED_VECTOR
  56 #endif
  57
  58 namespace configmgr
  59 {
  60     namespace configuration
  61     {
  62 //-------------------------------------------------------------------------
  63 // initialization helpers
  64 //-------------------------------------------------------------------------
  65 namespace
  66 {
  67     class CollectElementTrees : data::SetVisitor
  68     {
  69     public:
  70         CollectElementTrees(rtl::Reference<view::ViewStrategy> const& _xStrategy,
  71                             Tree* pParentTree, unsigned int nPos,
  72                             unsigned int nDepth,
  73                             rtl::Reference<Template> const& aTemplate,
  74                             TemplateProvider const& aTemplateProvider)
  75         : m_aTemplate(aTemplate)
  76         , m_aTemplateProvider(aTemplateProvider)
  77         , m_xStrategy(_xStrategy)
  78         , m_pParentTree(pParentTree)
  79         , m_nPos(nPos)
  80         , m_nDepth(nDepth)
  81         {
  82             OSL_ENSURE(m_aTemplate.is(),"WARNING: Collecting a set without a template");
  83         }
  84
  85         void collect(sharable::SetNode * node)
  86         {
  87             visitElements(node);
  88         }
  89
  90         ElementTreeData create(sharable::TreeFragment * elementTree)
  91         {
  92             OSL_ENSURE(collection.empty(),"warning: trying to reuse a full collection");
  93
  94             collection.resize(1); // make an empty one for case of failure
  95             this->visitTree(elementTree);
  96
  97             OSL_ENSURE(collection.size()==2,"warning: could not create an element");
  98             return collection.back();
  99         }
 100
 101         std::vector<ElementTreeData> collection;
 102
 103        private:
 104         using SetVisitor::handle;
 105
 106         virtual bool handle(sharable::Node * node);
 107
 108         virtual bool handle(sharable::ValueNode * node);
 109
 110         virtual bool handle(sharable::TreeFragment * tree);
 111
 112         void add(sharable::TreeFragment * node);
 113
 114         rtl::Reference<Template>                    m_aTemplate;
 115         TemplateProvider            m_aTemplateProvider;
 116         rtl::Reference<view::ViewStrategy>   m_xStrategy;
 117         Tree*   m_pParentTree;
 118         unsigned int    m_nPos;
 119         unsigned int    m_nDepth;
 120     };
 121     //-------------------------------------------------------------------------
 122
 123     static
 124     rtl::OUString validatedName(ElementTreeData const& aTree)
 125     {
 126         OSL_ENSURE(aTree.isValid(), "INTERNAL ERROR: Unexpected null tree constructed in set node");
 127         if (!aTree.isValid()) throw Exception("INTERNAL ERROR: Unexpected null tree in set node");
 128
 129         OSL_ENSURE(aTree->nodeCount(), "INTERNAL ERROR: Unexpected empty (!) tree constructed in set node");
 130         OSL_ENSURE(aTree->isValidNode(Tree::ROOT), "INTERNAL ERROR: Corrupt tree constructed in set node");
 131
 132         return aTree->getSimpleRootName();
 133     }
 134     //-------------------------------------------------------------------------
 135
 136     static
 137     bool isInDefault(SetEntry const& _anEntry)
 138     {
 139         if (!_anEntry.isValid()) return false;
 140
 141         node::Attributes aAttributes = _anEntry.getTreeView().getRootAttributes();
 142
 143         bool bReplaced = aAttributes.isReplacedForUser();
 144
 145         return !bReplaced;
 146     }
 147     //-------------------------------------------------------------------------
 148     bool CollectElementTrees::handle(sharable::ValueNode * node)
 149     {
 150         if (m_aTemplate.is())
 151         {
 152             OSL_ENSURE(m_aTemplate->isInstanceTypeKnown(),"ERROR: Template must have a validated type when building a set.");
 153             OSL_ENSURE(m_aTemplate->isInstanceValue(),"ERROR: Found a value node in a Complex Template Set");
 154
 155             if (!m_aTemplate->isInstanceValue())
 156                 throw Exception("INTERNAL ERROR: Corrupt tree contains a value node within a template-set");
 157
 158             com::sun::star::uno::Type aValueType = node->getValueType();
 159             com::sun::star::uno::Type aExpectedType = m_aTemplate->getInstanceType();
 160
 161             if (aValueType.getTypeClass() != aExpectedType.getTypeClass() &&
 162                 aExpectedType.getTypeClass() != uno::TypeClass_ANY &&
 163                 aValueType.getTypeClass() != uno::TypeClass_VOID)
 164             {
 165                 OSL_ENSURE(false, "WARNING: ValueType of set node does not match the template type");
 166             //  throw TypeMismatch(aValueType.getTypeName(),aExpectedType.getTypeName(), "INTERNAL ERROR: - Corrupt tree contains mistyped value node within a value-set")));
 167             }
 168         }
 169         return false;
 170     }
 171     //-------------------------------------------------------------------------
 172     bool CollectElementTrees::handle(sharable::Node * node)
 173     {
 174         (void) node; // avoid warnings
 175         OSL_ENSURE(!node->isValue(), "Unexpected: Value-node dispatched to wrong handler");
 176         if (m_aTemplate.is())
 177         {
 178             OSL_ENSURE(m_aTemplate->isInstanceTypeKnown(),"ERROR: Template must have a validated type when building a set.");
 179             OSL_ENSURE(!m_aTemplate->isInstanceValue(),"ERROR: Found a non-leaf node in a Value Set");
 180
 181             if (m_aTemplate->isInstanceValue())
 182                 throw Exception("INTERNAL ERROR: Corrupt tree contains a non-leaf node within a value-set");
 183
 184         }
 185         return false;
 186     }
 187     //-------------------------------------------------------------------------
 188     bool CollectElementTrees::handle(sharable::TreeFragment * tree)
 189     {
 190         bool done = visitNode(tree->getRootNode());
 191         if (!done) {
 192             add(tree);
 193         }
 194         return done;
 195     }
 196     //-------------------------------------------------------------------------
 197     void CollectElementTrees::add(sharable::TreeFragment * tree)
 198     {
 199         node::Attributes const aAttributes = tree->getAttributes();
 200
 201     bool bReadonly  = aAttributes.isReadonly();
 202     bool bInDefault = !aAttributes.isReplacedForUser();
 203
 204         rtl::Reference<view::ViewStrategy> xStrategy = !bReadonly ? m_xStrategy : view::createReadOnlyStrategy();
 205
 206         ElementTree * pNewTree;
 207         if (m_pParentTree)
 208             pNewTree = new ElementTree(xStrategy, *m_pParentTree, m_nPos, tree, m_nDepth, m_aTemplate, m_aTemplateProvider);
 209
 210         else
 211             pNewTree = new ElementTree(xStrategy, tree, m_nDepth, m_aTemplate, m_aTemplateProvider);
 212
 213         collection.push_back( ElementTreeData(pNewTree,bInDefault));
 214     }
 215 }
 216
 217 //-------------------------------------------------------------------------
 218 // class ElementSet
 219 //-------------------------------------------------------------------------
 220
 221 bool ElementSet::hasElement(rtl::OUString const& aName) const
 222 {
 223     return m_aData.find(aName) != m_aData.end();
 224 }
 225 //-------------------------------------------------------------------------
 226
 227 ElementTreeData* ElementSet::getElement(rtl::OUString const& aName)
 228 {
 229     Data::iterator it = m_aData.find(aName);
 230     if (it != m_aData.end())
 231         return &it->second;
 232     else
 233         return 0;
 234 }
 235 //-------------------------------------------------------------------------
 236
 237
 238 ElementTreeData const* ElementSet::getElement(rtl::OUString const& aName) const
 239 {
 240     Data::const_iterator it = m_aData.find(aName);
 241     if (it != m_aData.end())
 242         return &it->second;
 243     else
 244         return 0;
 245 }
 246 //-------------------------------------------------------------------------
 247
 248 ElementTreeData ElementSet::findElement(rtl::OUString const& aName)
 249 {
 250     ElementTreeData aRet;
 251
 252     Data::iterator it = m_aData.find(aName);
 253     if (it != m_aData.end())
 254         aRet = it->second;
 255
 256     return aRet;
 257 }
 258 //-------------------------------------------------------------------------
 259
 260 void ElementSet::insertElement(rtl::OUString const& aName, ElementTreeData const& aNewEntry)
 261 {
 262     bool bInserted = m_aData.insert(Data::value_type(aName, aNewEntry)).second;
 263
 264     OSL_ENSURE(bInserted,"INTERNAL ERROR: Inserted set Element was already present");
 265     if (!bInserted) throw Exception("INTERNAL ERROR: Inserted set Element was already present");
 266 }
 267 //-------------------------------------------------------------------------
 268
 269 ElementTreeData ElementSet::replaceElement(rtl::OUString const& aName, ElementTreeData const& aNewEntry)
 270 {
 271     OSL_ENSURE(m_aData.find(aName) != m_aData.end(),"INTERNAL ERROR: Replaced set Element is not present");
 272
 273     ElementTreeData& rElement = m_aData[aName];
 274
 275     ElementTreeData aOld = rElement;
 276     rElement = aNewEntry;
 277
 278     return aOld;
 279 }
 280 //-------------------------------------------------------------------------
 281
 282 ElementTreeData ElementSet::removeElement(rtl::OUString const& aName)
 283 {
 284     Data::iterator it = m_aData.find(aName);
 285     OSL_ENSURE(it != m_aData.end(),"INTERNAL ERROR: Removed set Element is not present");
 286
 287     ElementTreeData aOld;
 288     if (it != m_aData.end())
 289     {
 290         aOld = it->second;
 291         m_aData.erase(it);
 292     }
 293     return aOld;
 294 }
 295 //-------------------------------------------------------------------------
 296
 297 //-----------------------------------------------------------------------------
 298 // class SetEntry
 299 //-----------------------------------------------------------------------------
 300
 301 SetEntry::SetEntry(ElementTree* pTree_)
 302 : m_pTree(pTree_)
 303 {
 304     OSL_ENSURE(pTree_ == 0 || pTree_->isValidNode(Tree::ROOT),
 305                 "INTERNAL ERROR: Invalid empty tree used for SetEntry ");
 306 }
 307
 308 //-----------------------------------------------------------------------------
 309
 310 view::ViewTreeAccess SetEntry::getTreeView() const
 311 {
 312     OSL_ENSURE(isValid(), "Cannot get View Access for NULL SetEntry");
 313     return view::ViewTreeAccess(m_pTree);
 314 }
 315
 316 //-----------------------------------------------------------------------------
 317 //-------------------------------------------------------------------------
 318
 319 //-------------------------------------------------------------------------
 320 // class SetNodeImpl
 321 //-------------------------------------------------------------------------
 322
 323 SetNodeImpl::SetNodeImpl(sharable::SetNode * _pNodeRef,Template* pTemplate)
 324 : NodeImpl(reinterpret_cast<sharable::Node *>(_pNodeRef))
 325 ,m_aTemplate(pTemplate)
 326 ,m_aTemplateProvider()
 327 ,m_pParentTree(0)
 328 ,m_nContextPos(0)
 329 ,m_aInit(0)
 330 {
 331 }
 332     // unbind the original
 333 //-----------------------------------------------------------------------------
 334
 335 SetNodeImpl::~SetNodeImpl()
 336 {
 337 }
 338 //-----------------------------------------------------------------------------
 339
 340 void SetNodeImpl::rebuildFrom(SetNodeImpl& rOldData, sharable::SetNode * newNode)
 341 {
 342     m_aTemplate         = rOldData.m_aTemplate;
 343     m_aTemplateProvider = rOldData.m_aTemplateProvider;
 344     m_pParentTree       = rOldData.m_pParentTree;
 345     m_nContextPos       = rOldData.m_nContextPos;
 346     m_aInit             = rOldData.m_aInit;
 347
 348     if (rOldData.implHasLoadedElements())
 349     {
 350         rOldData.doTransferElements(m_aDataSet);
 351         implRebuildElements(newNode);
 352         OSL_ASSERT(this->implHasLoadedElements());
 353     }
 354     else
 355         OSL_ASSERT(!this->implHasLoadedElements());
 356
 357     rOldData.m_aTemplate.clear();
 358     rOldData.m_aTemplateProvider = TemplateProvider();
 359     rOldData.m_pParentTree = 0;
 360     rOldData.m_nContextPos = 0;
 361
 362 }
 363
 364 //-----------------------------------------------------------------------------
 365 void SetNodeImpl::doTransferElements(ElementSet& rReplacement)
 366 {
 367     m_aDataSet.swap(rReplacement);
 368 }
 369 //-----------------------------------------------------------------------------
 370
 371 void SetNodeImpl::implRebuildElements(sharable::SetNode * newNode)
 372 {
 373     OSL_ENSURE(m_pParentTree,"Cannot rebuild set without context tree");
 374     rtl::Reference<view::ViewStrategy> xNewStrategy = m_pParentTree->getViewBehavior();
 375
 376     for(ElementSet::Iterator it = m_aDataSet.begin(), stop = m_aDataSet.end();
 377     it != stop;
 378     ++it)
 379     {
 380         OSL_ASSERT(it->isValid());
 381         if (!it->isValid()) continue;
 382
 383         ElementTreeData aElement = *it;
 384         rtl::OUString aName = aElement->getSimpleRootName();
 385
 386         sharable::TreeFragment * aNewElementAccess = newNode->getElement(aName);
 387         OSL_ASSERT(
 388             aNewElementAccess != 0 && aElement->getOriginalTreeAccess() != 0);
 389
 390     aElement->rebuild(xNewStrategy,aNewElementAccess);
 391     }
 392 }
 393 //-----------------------------------------------------------------------------
 394
 395 sharable::SetNode * SetNodeImpl::getDataAccess() const
 396 {
 397     sharable::Node * node = getOriginalNodeAccess();
 398     OSL_ASSERT(node != 0 && node->isSet());
 399     return &node->set;
 400 }
 401 //-----------------------------------------------------------------------------
 402
 403 Tree*   SetNodeImpl::getParentTree() const
 404 {
 405     OSL_ENSURE(m_pParentTree,"Set Node: Parent tree not set !");
 406     return m_pParentTree;
 407 }
 408 //-----------------------------------------------------------------------------
 409
 410 unsigned int    SetNodeImpl::getContextOffset() const
 411 {
 412     OSL_ENSURE(m_nContextPos,"Set Node: Position within parent tree not set !");
 413     return m_nContextPos;
 414 }
 415 //-----------------------------------------------------------------------------
 416
 417 bool SetNodeImpl::doIsEmpty() const
 418 {
 419     /*
 420     for(ElementSet::Iterator it = m_aDataSet.begin(), stop = m_aDataSet.end();
 421         it != stop;
 422         ++it)
 423     {
 424         if (!it->isEmpty())
 425             return false;
 426     }
 427     return true;
 428     */
 429     return m_aDataSet.isEmpty();
 430 }
 431 //-------------------------------------------------------------------------
 432
 433 ElementTree* SetNodeImpl::doFindElement(rtl::OUString const& aName)
 434 {
 435     return m_aDataSet.findElement(aName).get();
 436 }
 437 //-------------------------------------------------------------------------
 438 void SetNodeImpl::doDifferenceToDefaultState(SubtreeChange& _rChangeToDefault, ISubtree& _rDefaultTree)
 439 {
 440     OSL_ENSURE(implHasLoadedElements(),"Should not query difference to default state for set that is not loaded");
 441     implDifferenceToDefaultState(_rChangeToDefault,_rDefaultTree);
 442 }
 443 //-----------------------------------------------------------------------------
 444
 445 SetElementChangeImpl* SetNodeImpl::doAdjustToAddedElement(rtl::OUString const& aName, AddNode const& aAddNodeChange, ElementTreeData const & aNewElement)
 446 {
 447     return implAdjustToAddedElement(aName,aNewElement,aAddNodeChange.isReplacing());
 448 }
 449 //-------------------------------------------------------------------------
 450
 451 SetElementChangeImpl* SetNodeImpl::implAdjustToAddedElement(rtl::OUString const& aName, ElementTreeData const & aNewElement, bool _bReplacing)
 452 {
 453     { (void)_bReplacing; }
 454     OSL_ENSURE( validatedName(aNewElement) == aName, "Unexpected name on new element" );
 455
 456     if (hasStoredElement(aName))
 457     {
 458         OSL_ENSURE( _bReplacing, "Added Element already exists - replacing" );
 459
 460         ElementTreeData aOldElement = this->replaceElement(aName,aNewElement);
 461
 462         return implCreateReplace(aName,aNewElement,aOldElement);
 463     }
 464     else
 465     {
 466         OSL_ENSURE( !_bReplacing, "Replaced Element doesn't exist - simply adding" );
 467         this->insertElement(aName,aNewElement);
 468
 469         return implCreateInsert(aName,aNewElement);
 470     }
 471 }
 472 //-------------------------------------------------------------------------
 473
 474 SetElementChangeImpl* SetNodeImpl::doAdjustToRemovedElement(rtl::OUString const& aName, RemoveNode const& /*aRemoveNodeChange*/)
 475 {
 476     return implAdjustToRemovedElement(aName);
 477 }
 478 //-------------------------------------------------------------------------
 479
 480 SetElementChangeImpl* SetNodeImpl::implAdjustToRemovedElement(rtl::OUString const& aName)
 481 {
 482     if (ElementTreeData* pOriginal = getStoredElement(aName))
 483     {
 484         ElementTreeData aOldElement = *pOriginal;
 485         this->removeElement(aName);
 486
 487         return implCreateRemove(aName,aOldElement);
 488     }
 489     else
 490     {
 491         OSL_ENSURE( false, "Removed Element doesn't exist - ignoring" );
 492         return 0;
 493     }
 494 }
 495 //-------------------------------------------------------------------------
 496
 497 SetElementChangeImpl* SetNodeImpl::implCreateInsert(rtl::OUString const& aName, ElementTreeData const& aNewElement) const
 498 {
 499     Path::Component aFullName = Path::makeCompositeName(aName, this->getElementTemplate()->getName());
 500
 501     SetElementChangeImpl* pRet = new SetInsertImpl(aFullName, aNewElement.tree, true);
 502     pRet->setTarget( getParentTree(), getContextOffset() );
 503     return pRet;
 504 }
 505 //-------------------------------------------------------------------------
 506
 507 SetElementChangeImpl* SetNodeImpl::implCreateReplace(rtl::OUString const& aName, ElementTreeData const& aNewElement, ElementTreeData const& aOldElement) const
 508 {
 509     Path::Component aFullName = Path::makeCompositeName(aName, this->getElementTemplate()->getName());
 510
 511     SetElementChangeImpl* pRet = new SetReplaceImpl(aFullName, aNewElement.tree, aOldElement.tree);
 512     pRet->setTarget( getParentTree(), getContextOffset() );
 513     return pRet;
 514 }
 515 //-------------------------------------------------------------------------
 516
 517 SetElementChangeImpl* SetNodeImpl::implCreateRemove(rtl::OUString const& aName, ElementTreeData const& aOldElement) const
 518 {
 519     Path::Component aFullName = Path::makeCompositeName(aName, this->getElementTemplate()->getName());
 520
 521     SetElementChangeImpl* pRet = new SetRemoveImpl(aFullName, aOldElement.tree);
 522     pRet->setTarget( getParentTree(), getContextOffset() );
 523     return pRet;
 524 }
 525 //-------------------------------------------------------------------------
 526
 527 void SetNodeImpl::insertElement(rtl::OUString const& aName, ElementTreeData const& aNewElement)
 528 {
 529     attach(aNewElement,aName);
 530     try
 531     {
 532         m_aDataSet.insertElement(aName,aNewElement);
 533     }
 534     catch (std::exception&)
 535     {
 536         detach(aNewElement);
 537         throw;
 538     }
 539 }
 540 //-------------------------------------------------------------------------
 541
 542 ElementTreeData SetNodeImpl::replaceElement(rtl::OUString const& aName, ElementTreeData const& aNewElement)
 543 {
 544     attach(aNewElement,aName);
 545     try
 546     {
 547         ElementTreeData aOldElement = m_aDataSet.replaceElement(aName,aNewElement);
 548         detach(aOldElement);
 549         return aOldElement;
 550     }
 551     catch (std::exception&)
 552     {
 553         detach(aNewElement);
 554         throw;
 555     }
 556 }
 557 //-------------------------------------------------------------------------
 558
 559 ElementTreeData SetNodeImpl::removeElement(rtl::OUString const& aName)
 560 {
 561     ElementTreeData aOldElement = m_aDataSet.removeElement(aName);
 562     detach(aOldElement);
 563     return aOldElement;
 564 }
 565 //-------------------------------------------------------------------------
 566 SetNodeVisitor::Result  SetNodeImpl::doDispatchToElements(SetNodeVisitor& aVisitor)
 567 {
 568     SetNodeVisitor::Result eRet = SetNodeVisitor::CONTINUE;
 569     for(ElementSet::Iterator it = m_aDataSet.begin(), stop = m_aDataSet.end();
 570         it != stop && eRet != SetNodeVisitor::DONE;
 571         ++it)
 572     {
 573         eRet = aVisitor.visit( SetEntry(it->get()) );
 574     }
 575     return eRet;
 576 }
 577 //-----------------------------------------------------------------------------
 578
 579 void SetNodeImpl::attach(ElementTreeData const& aNewElement, rtl::OUString const& aName)
 580 {
 581     // check for name (this also reject NULLs, therefore it should go first)
 582     rtl::OUString aActualName = validatedName(aNewElement);
 583
 584     Tree*       pParentContext  = getParentTree();
 585     unsigned int        nParentOffset   = getContextOffset();
 586
 587     OSL_ENSURE(nParentOffset != 0 && pParentContext != 0,"INTERNAL ERROR: Set has no context");
 588
 589     bool bHasContext = (aNewElement->getContextTree() != 0);
 590
 591     if (bHasContext)
 592     {
 593         if (aNewElement->getContextTree() != pParentContext)
 594         {
 595             OSL_ENSURE(false,"INTERNAL ERROR: New set element belongs to another context tree" );
 596             throw Exception("INTERNAL ERROR: New set element belongs to another context tree" );
 597         }
 598         if (aNewElement->getContextNode() != nParentOffset)
 599         {
 600             OSL_ENSURE(false,"INTERNAL ERROR: New set element belongs to another context node" );
 601             throw Exception("INTERNAL ERROR: New set element belongs to another context node" );
 602         }
 603     }
 604     else
 605     {
 606         OSL_ENSURE(aNewElement->getContextNode() == 0, "INTERNAL ERROR: New element has context position without a parent");
 607         aNewElement->moveTree(pParentContext,nParentOffset);
 608     }
 609
 610     // check for and correct a misnomer - do only after parenthood is assured (else we don't own it anyways)
 611     if (aName != aActualName)
 612     {
 613     //  OSL_ENSURE(aActualName.isEmpty(), "WARNING: Wrongly named tree inserted in set node");
 614         aNewElement->renameTree(aName);
 615
 616         aActualName = validatedName(aNewElement);
 617         if (aName !=aActualName )
 618         {
 619             OSL_ENSURE(false, "INTERNAL ERROR: Cannot rename tree in set node");
 620             throw Exception("INTERNAL ERROR: Cannot rename tree for insertion into set node");
 621         }
 622     }
 623 }
 624 //-------------------------------------------------------------------------
 625
 626 void SetNodeImpl::detach(ElementTreeData const& aOldElement)
 627 {
 628     if (aOldElement.isValid())
 629     {
 630         aOldElement->detachTree();
 631     }
 632 }
 633 //-------------------------------------------------------------------------
 634
 635 ElementTreeData SetNodeImpl::entryToElement(SetEntry const& _anEntry)
 636 {
 637     ElementTree * pTree = _anEntry.tree();
 638     return ElementTreeData(pTree, isInDefault(_anEntry));
 639 }
 640 //-------------------------------------------------------------------------
 641
 642
 643 SetElementChangeImpl* SetNodeImpl::doAdjustChangedElement(NodeChangesInformation& rLocalChanges, rtl::OUString const& aName, Change const& _aElementChange)
 644 {
 645     SetElementChangeImpl* pThisChange  = NULL;
 646
 647     if (ElementTreeData* pElement = getStoredElement(aName))
 648     {
 649         OSL_ASSERT(pElement->isValid());
 650
 651         if (SubtreeChange const * subtreeChange = dynamic_cast< SubtreeChange const * >(&_aElementChange))
 652         {
 653             // recurse to element tree
 654             Tree * elementTree = pElement->get();
 655
 656             view::getViewBehavior(elementTree)->adjustToChanges(rLocalChanges, view::getRootNode(elementTree), *subtreeChange);
 657         }
 658         else if (ValueChange const * valueChange = dynamic_cast< ValueChange const * >(&_aElementChange))
 659         {
 660             // make an element for the old element
 661             std::auto_ptr<ValueNode> aOldNode = OTreeNodeConverter().createCorrespondingNode(*valueChange);
 662             aOldNode->setValue(valueChange->getOldValue());
 663
 664             bool bWasDefault = (valueChange->getMode() == ValueChange::wasDefault);
 665
 666             std::auto_ptr<INode> aBasePtr(aOldNode.release());
 667             rtl::OUString aElementTypeName = getElementTemplate()->getName();
 668             rtl::Reference< data::TreeSegment > aOldBaseTree = data::TreeSegment::create( aBasePtr, aElementTypeName );
 669
 670             rtl::Reference<ElementTree> aOldElement = new ElementTree(aOldBaseTree, getElementTemplate(), getTemplateProvider());
 671
 672             OSL_ASSERT(aOldBaseTree.is()); // the tree took ownership
 673             OSL_ASSERT(aOldElement->isFree()); // the tree is free-floating
 674
 675             pThisChange = implCreateReplace(aName,*pElement,ElementTreeData(aOldElement,bWasDefault));
 676         }
 677         else
 678             OSL_ENSURE( false, "Unexpected kind of change to set element" );
 679
 680     }
 681     else
 682     {
 683         // could be changed to do an insert instead (?)
 684         OSL_ENSURE( false, "Changed Element doesn't exist - (and not adding now)" );
 685     }
 686     return pThisChange;
 687 }
 688 //-------------------------------------------------------------------------
 689
 690 bool SetNodeImpl::implHasLoadedElements() const
 691 {
 692     return m_aInit == 0; // cannot check whether init was called though ...
 693 }
 694 //-----------------------------------------------------------------------------
 695
 696 void SetNodeImpl::initElements(TemplateProvider const& aTemplateProvider,Tree& rParentTree,unsigned int nPos,unsigned int nDepth)
 697 {
 698     OSL_ENSURE(m_pParentTree == 0 || m_pParentTree == &rParentTree,     "WARNING: Set Node: Changing parent");
 699     OSL_ENSURE(m_nContextPos == 0 || m_nContextPos == nPos,                     "WARNING: Set Node: Changing location within parent");
 700     m_pParentTree = &rParentTree;
 701     m_nContextPos = nPos;
 702
 703     OSL_ENSURE(!m_aTemplateProvider.isValid() || !implHasLoadedElements(),"ERROR: Reinitializing set"); //doClearElements();
 704     OSL_ASSERT(doIsEmpty()); //doClearElements();
 705
 706     OSL_ENSURE(!m_aTemplate.is() || m_aTemplate->isInstanceTypeKnown(),"ERROR: Need a type-validated template to fill a set");
 707     OSL_ENSURE(aTemplateProvider.isValid() || nDepth == 0 || m_aTemplate->isInstanceValue(), "ERROR: Need a template provider to fill a non-primitive set");
 708
 709     if (nDepth > 0) // dont set a template provider for zero-depth sets
 710     {
 711         m_aInit = nDepth;
 712         m_aTemplateProvider = aTemplateProvider;
 713     }
 714 }
 715 //-----------------------------------------------------------------------------
 716
 717 bool SetNodeImpl::implLoadElements()
 718 {
 719     if (m_aInit > 0)
 720     {
 721     OSL_ENSURE(!getElementTemplate().is() || getElementTemplate()->isInstanceTypeKnown(),"ERROR: Need a type-validated template to fill a set");
 722     OSL_ENSURE(getTemplateProvider().isValid() || getElementTemplate()->isInstanceValue(), "ERROR: Need a template provider to fill a non-primitive set");
 723
 724         unsigned int nDepth = m_aInit;
 725     implInitElements(this->getDataAccess(),nDepth);
 726     m_aInit = 0;
 727     }
 728     OSL_ASSERT(implHasLoadedElements());
 729
 730     return m_aInit == 0;
 731 }
 732 //-----------------------------------------------------------------------------
 733
 734 void SetNodeImpl::implEnsureElementsLoaded()
 735 {
 736     if (!implLoadElements())
 737         throw ConstraintViolation("Trying to access set elements beyond the loaded nestíng level");
 738 }
 739 //-----------------------------------------------------------------------------
 740
 741 void SetNodeImpl::implInitElements(sharable::SetNode * node, unsigned int nDepth)
 742 {
 743     Tree* pThisTree = getParentTree();
 744
 745     OSL_ENSURE(pThisTree,"Cannot load elements of a set that has no parent tree");
 746
 747     CollectElementTrees aCollector( pThisTree->getViewBehavior(), pThisTree, getContextOffset(),
 748                                     nDepth, getElementTemplate(), getTemplateProvider() );
 749     aCollector.collect(node);
 750
 751     for(std::vector<ElementTreeData>::const_iterator it = aCollector.collection.begin(), stop = aCollector.collection.end();
 752         it != stop; ++it)
 753     {
 754         implInitElement(implValidateElement(*it));
 755     }
 756 }
 757 //-------------------------------------------------------------------------
 758
 759 void SetNodeImpl::implInitElement(ElementTreeData const& aNewElement)
 760 {
 761     OSL_PRECOND(aNewElement.isValid(),"INTERNAL ERROR: Set element is NULL");
 762     OSL_ENSURE(!aNewElement->isFree(),"INTERNAL ERROR: Set element is free-floating");
 763
 764     OSL_ENSURE(aNewElement->getContextTree() == getParentTree(),"INTERNAL ERROR: Set element has wrong context tree");
 765     OSL_ENSURE(aNewElement->getContextNode() == getContextOffset(),"INTERNAL ERROR: Set element has wrong context node");
 766
 767     rtl::OUString aName = validatedName(aNewElement);
 768
 769     OSL_ENSURE(aName.getLength() != 0,"INTERNAL ERROR: Unnamed element in set");
 770     OSL_ENSURE(m_aDataSet.getElement(aName) == 0,"INTERNAL ERROR: Duplicate element name in set");
 771
 772     m_aDataSet.insertElement(aName,aNewElement);
 773 }
 774 //-------------------------------------------------------------------------
 775
 776 ElementTreeData SetNodeImpl::makeAdditionalElement(rtl::Reference<view::ViewStrategy> const& _xStrategy, AddNode const& aAddNodeChange, unsigned int nDepth)
 777 {
 778     OSL_ENSURE(aAddNodeChange.wasInserted(), "Cannot integrate element that is not in tree yet");
 779
 780     sharable::TreeFragment * aAddedTree = aAddNodeChange.getInsertedTree();
 781     // need 'unsafe', because ownership would be gone when notifications are sent
 782     if (aAddedTree != NULL)
 783     {
 784         CollectElementTrees aCollector( _xStrategy, getParentTree(), getContextOffset(),
 785                                         nDepth, getElementTemplate(), getTemplateProvider() );
 786
 787         return implValidateElement(aCollector.create(aAddedTree));
 788     }
 789
 790     return ElementTreeData();
 791 }
 792 //-------------------------------------------------------------------------
 793
 794 ElementTreeData SetNodeImpl::implValidateElement(ElementTreeData const& aNewElement)
 795 {
 796     rtl::Reference<Template> aTemplate = getElementTemplate();
 797     OSL_ENSURE(aTemplate.is(),"INTERNAL ERROR: No template in set node");
 798     OSL_ENSURE(aTemplate->isInstanceTypeKnown(),"INTERNAL ERROR: Unspecifed template in set node");
 799
 800     OSL_ENSURE(aNewElement.isValid(),"INTERNAL ERROR: Unexpected NULL element in set node");
 801     if (aNewElement.isValid())
 802     {
 803         if (aTemplate->isInstanceValue())
 804         {
 805             if (aNewElement->nodeCount() == 0)
 806             {
 807                 OSL_ENSURE(false,"INTERNAL ERROR: Invalid (empty) element tree in value set");
 808                 throw Exception("INTERNAL ERROR: Invalid (empty) element tree in value set");
 809             }
 810             if (aNewElement->nodeCount() > 1)
 811             {
 812                 OSL_ENSURE(false,"INTERNAL ERROR: Complex element tree in value set");
 813                 throw Exception("INTERNAL ERROR: Complex element tree in value set");
 814             }
 815
 816             view::Node aElementRoot = view::getRootNode(aNewElement.get());
 817
 818             OSL_ENSURE(aElementRoot.isValueNode(),"INTERNAL ERROR: Inserting complex type into value set node");
 819
 820             view::ValueNode aValueNode(aElementRoot);
 821             com::sun::star::uno::Type aValueType = aValueNode.get_impl()->getValueType();
 822
 823             OSL_ENSURE( aValueType.getTypeClass() != uno::TypeClass_INTERFACE,
 824                         "INTERNAL ERROR: Inserting complex type into value set node");
 825
 826             com::sun::star::uno::Type aElementType      = aTemplate->getInstanceType();
 827
 828             if (aValueType != aElementType)
 829             {
 830                 // handle 'Any'
 831                 if (aElementType.getTypeClass() != uno::TypeClass_ANY)
 832                 {
 833                     OSL_ENSURE(false,"INTERNAL ERROR:  ´Wrong value type inserting into value set");
 834                     throw TypeMismatch(aValueType.getTypeName(), aElementType.getTypeName(),
 835                                         "- INTERNAL ERROR: Mistyped element in value set");
 836                 }
 837             }
 838         }
 839         else // a complete tree
 840         {
 841             // TODO: add some validation here
 842             if (!aNewElement->isTemplateInstance())
 843             {
 844                 throw TypeMismatch(     rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<Unknown> [Missing Template]")),
 845                                     aTemplate->getName(),
 846                                     " - Trying to insert element without template into set");
 847             }
 848             if (!aNewElement->isInstanceOf(aTemplate))
 849             {
 850                 throw TypeMismatch(     aNewElement->getTemplate()->getPathString(),
 851                                     aTemplate->getPathString(),
 852                                     " - Trying to insert element with wrong template into set");
 853             }
 854         }
 855     }
 856     return aNewElement;
 857 }
 858 //-------------------------------------------------------------------------
 859
 860 namespace
 861 {
 862     //-------------------------------------------------------------------------
 863     class DiffToDefault : data::SetVisitor
 864     {
 865         SubtreeChange&          m_rChange;
 866         ISubtree&               m_rDefaultTree;
 867         OTreeChangeFactory&     m_rChangeFactory;
 868     public:
 869         explicit
 870         DiffToDefault(SubtreeChange& _rChange, ISubtree& _rDefaultTree)
 871         : m_rChange(_rChange)
 872         , m_rDefaultTree(_rDefaultTree)
 873         , m_rChangeFactory( getDefaultTreeChangeFactory() )
 874         {
 875         }
 876
 877         void diff(sharable::SetNode * actualTree)
 878         {
 879             translate(m_rDefaultTree);
 880             visitElements(actualTree);
 881         }
 882
 883     private:
 884         void translate(ISubtree& _rDefaultTree);
 885         void handleDefault(rtl::Reference< data::TreeSegment > const & _pDefaultElement);
 886         void handleActual(sharable::TreeFragment * element);
 887
 888         using SetVisitor::handle;
 889         virtual bool handle(sharable::TreeFragment * tree)
 890         { handleActual(tree); return false; }
 891     };
 892     //-------------------------------------------------------------------------
 893
 894     void DiffToDefault::translate(ISubtree& _rDefaultTree)
 895     {
 896         rtl::OUString aTypeName = _rDefaultTree.getElementTemplateName();
 897         OSL_ENSURE(aTypeName.getLength(),"Cannot get element type for default set");
 898
 899         CollectNames aCollector;
 900         aCollector.applyToChildren(_rDefaultTree);
 901
 902         std::vector<rtl::OUString> const& aNames = aCollector.list();
 903
 904         for(std::vector<rtl::OUString>::const_iterator it = aNames.begin(); it != aNames.end(); ++it)
 905         {
 906             std::auto_ptr<INode> aChild = _rDefaultTree.removeChild(*it);
 907             handleDefault( data::TreeSegment::create(aChild,aTypeName) );
 908         }
 909
 910     }
 911     //-------------------------------------------------------------------------
 912
 913     void DiffToDefault::handleDefault(rtl::Reference< data::TreeSegment > const &_pDefaultElement)
 914     {
 915         OSL_PRECOND(_pDefaultElement.is(), "Unexpected NULL default node");
 916
 917         rtl::OUString sName = _pDefaultElement->fragment->getName();
 918
 919         OSL_ENSURE(_pDefaultElement->fragment->getAttributes().isDefault(), "Missing default state on default element tree");
 920         OSL_ENSURE(_pDefaultElement->fragment->nodes[0].isDefault(), "Missing default attribute on default node");
 921
 922         std::auto_ptr<AddNode> pAddIt( m_rChangeFactory.createAddNodeChange(_pDefaultElement, sName,true) );
 923
 924         m_rChange.addChange(base_ptr(pAddIt));
 925     }
 926     //-------------------------------------------------------------------------
 927
 928 // -----------------------------------------------------------------------------
 929     void DiffToDefault::handleActual(sharable::TreeFragment * element)
 930     {
 931         bool bDefaultElement = element->getRootNode()->isDefault();
 932
 933         rtl::OUString sName = element->getName();
 934
 935         if (Change* pDefaultNode = m_rChange.getChange(sName) )
 936         {
 937
 938             if (AddNode * addNode = dynamic_cast< AddNode * >(pDefaultNode))
 939             {
 940                 if (bDefaultElement)
 941                 {
 942                     rtl::Reference< data::TreeSegment > aDefaultTree = addNode->getNewTree();
 943                     m_rDefaultTree.addChild(data::convertTree(aDefaultTree.is() ? aDefaultTree->fragment : 0, true));
 944
 945                     // no change needed - remove the change and recover the default
 946                     m_rChange.removeChange(sName);
 947                 }
 948             }
 949             else
 950             {
 951                 // should never happen
 952                 OSL_ASSERT(false);
 953                 if (bDefaultElement) m_rChange.removeChange(sName);
 954             }
 955         }
 956         else
 957         {
 958             OSL_ENSURE(!bDefaultElement, "Node marked 'default' not found in actual default data");
 959
 960             std::auto_ptr<RemoveNode> pRemoveIt( m_rChangeFactory.createRemoveNodeChange(sName,true) );
 961             // pRemoveIt->expectRemovedNode(pActualNode);
 962             m_rChange.addChange(base_ptr(pRemoveIt));
 963         }
 964     }
 965 //-----------------------------------------------------------------------------
 966 }
 967 //-----------------------------------------------------------------------------
 968 void SetNodeImpl::implDifferenceToDefaultState(SubtreeChange& _rChangeToDefault, ISubtree& _rDefaultTree) const
 969 {
 970     DiffToDefault(_rChangeToDefault,_rDefaultTree).diff( getDataAccess() );
 971 }
 972 //-----------------------------------------------------------------------------
 973 void SetNodeImpl::convertChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChange,
 974                                  unsigned int nDepth)
 975 {
 976     OSL_ASSERT(nDepth > 0);
 977
 978     if (Tree* pParentTree = this->getParentTree())
 979     {
 980         unsigned int nNode = getContextOffset();
 981
 982         OSL_ENSURE(pParentTree->isValidNode(nNode), "Invalid context node in Set");
 983         OSL_ENSURE(view::Node(pParentTree, nNode).get_impl() == this,
 984                     "Wrong context node in Set");
 985
 986         CollectChanges aCollector(rLocalChanges, *pParentTree, nNode, getElementTemplate(), nDepth);
 987
 988         aCollector.collectFromChildren(rExternalChange);
 989     }
 990     else
 991         OSL_ENSURE(false, "Missing context tree in Set");
 992 }
 993 //-----------------------------------------------------------------------------
 994
 995     }
 996 }
 997