Set element initialization is now deferred; External changes are intergrated as NodeChangeInformation

6 files changed, 506 insertions, 231 deletions

diff --git a/configmgr/source/treemgr/nodeimpl.cxx b/configmgr/source/treemgr/nodeimpl.cxx
index 82cc2f3b59..eeaa83fdbc 100644
--- a/configmgr/source/treemgr/nodeimpl.cxx
+++ b/configmgr/source/treemgr/nodeimpl.cxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: nodeimpl.cxx,v $
  *
- *  $Revision: 1.7 $
+ *  $Revision: 1.8 $
  *
- *  last change: $Author: jb $ $Date: 2000-12-07 14:48:18 $
+ *  last change: $Author: jb $ $Date: 2001-02-13 17:20:54 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -64,7 +64,9 @@
 #include "treeimpl.hxx"
 #include "nodechange.hxx"
 #include "nodechangeimpl.hxx"
+#include "nodechangeinfo.hxx"
 #include "change.hxx"
+#include "collectchanges.hxx"
 
 #include "cmtreemodel.hxx"
 
@@ -107,6 +109,17 @@ void NodeImpl::makeIndirect(NodeImplHolder&	aThis,bool bIndirect)
     }
 }
 
+// helper for derived classes
+//-----------------------------------------------------------------------------
+
+void NodeImpl::addLocalChangeHelper( NodeChangesInformation& rLocalChanges_, NodeChange const& aChange_)
+{
+    NodeChangeInformation aThisInfo;
+    if (aChange_.getChangeInfo(aThisInfo))
+        rLocalChanges_.push_back( aThisInfo );
+}
+
+
 // Specific types of nodes
 //-----------------------------------------------------------------------------
 
@@ -126,25 +139,25 @@ GroupNodeImpl::GroupNodeImpl(GroupNodeImpl& rOriginal)
 }
 //-----------------------------------------------------------------------------
 
-NodeType::Enum	GroupNodeImpl::getType() const
+NodeType::Enum	GroupNodeImpl::doGetType() const
 {
     return NodeType::eGROUP;
 }
 //-----------------------------------------------------------------------------
 
-void GroupNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void GroupNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
     fetchInfo(rInfo,m_rOriginal);
 }
 //-----------------------------------------------------------------------------
 
-void GroupNodeImpl::setNodeName(Name const& aName)
+void GroupNodeImpl::doSetNodeName(Name const& aName)
 {
     m_rOriginal.setName(aName.toString());
 }
 //-----------------------------------------------------------------------------
 
-void GroupNodeImpl::dispatch(INodeHandler& rHandler)
+void GroupNodeImpl::doDispatch(INodeHandler& rHandler)
 {
     rHandler.handle(*this);
 }
@@ -159,8 +172,30 @@ SetEntry::SetEntry(ElementTreeImpl* pTree_)
     OSL_ENSURE(pTree_ == 0 || pTree_->isValidNode(pTree_->root()),
                 "INTERNAL ERROR: Invalid empty tree used for SetEntry ");
 }
+
+//-----------------------------------------------------------------------------
+// struct SetNodeImpl::InitHelper
 //-----------------------------------------------------------------------------
 
+struct SetNodeImpl::InitHelper 
+{
+    TemplateProvider	aTemplateProvider;
+    TreeDepth			nLoadDepth;
+
+    InitHelper()
+        : aTemplateProvider()
+        , nLoadDepth(0)
+    {
+    }
+
+    InitHelper(TemplateProvider const& aTP_, TreeDepth nDepth_)
+        : aTemplateProvider(aTP_)
+        , nLoadDepth(nDepth_)
+    {
+        OSL_ASSERT(nDepth_ > 0 || !aTP_.isValid());
+    }
+};
+
 //-----------------------------------------------------------------------------
 // class SetNodeImpl
 //-----------------------------------------------------------------------------
@@ -170,6 +205,7 @@ SetNodeImpl::SetNodeImpl(ISubtree& rOriginal,Template* pTemplate)
 ,m_aTemplate(pTemplate)
 ,m_pParentTree(0)
 ,m_nContextPos(0)
+,m_pInit(new InitHelper())
 {
 }
 //-----------------------------------------------------------------------------
@@ -179,11 +215,18 @@ SetNodeImpl::SetNodeImpl(SetNodeImpl& rOriginal)
 ,m_aTemplate(rOriginal.m_aTemplate)
 ,m_pParentTree(rOriginal.m_pParentTree)
 ,m_nContextPos(rOriginal.m_nContextPos)
+,m_pInit(rOriginal.m_pInit)
 {
     // unbind the original
     rOriginal.m_aTemplate.unbind();
     rOriginal.m_pParentTree = 0;
     rOriginal.m_nContextPos = 0;
+
+}
+//-----------------------------------------------------------------------------
+
+SetNodeImpl::~SetNodeImpl() 
+{
 }
 //-----------------------------------------------------------------------------
 
@@ -201,32 +244,121 @@ NodeOffset	SetNodeImpl::getContextOffset() const
 }
 //-----------------------------------------------------------------------------
 
-void SetNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+bool SetNodeImpl::isEmpty()					
+{ 
+    return !implLoadElements() || doIsEmpty(); 
+}
+//-----------------------------------------------------------------------------
+
+SetEntry SetNodeImpl::findElement(Name const& aName)
+{ 
+    implEnsureElementsLoaded();
+    return doFindElement(aName);
+};
+//-----------------------------------------------------------------------------
+
+SetEntry SetNodeImpl::findAvailableElement(Name const& aName)
+{ 
+    if (implLoadElements())
+        return doFindElement(aName);
+    else
+        return SetEntry(0);
+};
+//-----------------------------------------------------------------------------
+
+void SetNodeImpl::insertElement(Name const& aName, SetEntry const& aNewEntry) 
+{ 
+    // cannot insert, if we cannot check for collisions
+    implEnsureElementsLoaded();
+    doInsertElement(aName,aNewEntry); 
+}
+//-----------------------------------------------------------------------------
+
+void SetNodeImpl::removeElement(Name const& aName)							
+{ 
+    // cannot remove, if we cannot check for existance
+    implEnsureElementsLoaded();
+    doRemoveElement(aName); 
+}
+//-----------------------------------------------------------------------------
+
+SetNodeVisitor::Result SetNodeImpl::dispatchToElements(SetNodeVisitor& aVisitor)		
+{ 
+    if (implLoadElements())
+        return doDispatchToElements(aVisitor); 
+
+    else
+        return SetNodeVisitor::CONTINUE;
+}
+//-----------------------------------------------------------------------------
+
+void SetNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
     fetchInfo(rInfo,m_rOriginal);
 }
 //-----------------------------------------------------------------------------
 
-void SetNodeImpl::setNodeName(Name const& aName)
+void SetNodeImpl::doSetNodeName(Name const& aName)
 {
     m_rOriginal.setName(aName.toString());
 }
-//-----------------------------------------------------------------------------
 
-NodeType::Enum	SetNodeImpl::getType() const
+//-----------------------------------------------------------------------------
+NodeType::Enum	SetNodeImpl::doGetType() const
 {
     return NodeType::eSET;
 }
 
 //-----------------------------------------------------------------------------
-
-void SetNodeImpl::dispatch(INodeHandler& rHandler)
+void SetNodeImpl::doDispatch(INodeHandler& rHandler)
 {
     rHandler.handle(*this);
 }
 
 //-----------------------------------------------------------------------------
+bool SetNodeImpl::implHasLoadedElements() const 
+{
+    return m_pInit.get() == 0; // cannot check whether init was called though ...
+}
+
+//-----------------------------------------------------------------------------
+bool SetNodeImpl::implLoadElements() 
+{
+    if (m_pInit.get() != 0 && m_pInit->nLoadDepth > 0)
+    {
+        implInitElements(*m_pInit);
+        m_pInit.reset();
 
+    }
+    OSL_ASSERT(implHasLoadedElements() || m_pInit->nLoadDepth == 0);
+
+    return m_pInit.get() == 0;
+}
+
+//-----------------------------------------------------------------------------
+void SetNodeImpl::implEnsureElementsLoaded() 
+{
+    if (!implLoadElements())
+        throw ConstraintViolation("Trying to access set elements beyond the loaded nestíng level");
+}
+
+//-----------------------------------------------------------------------------
+bool SetNodeImpl::implInitElements(InitHelper const& aInit) 
+{
+    TreeDepth nDepth = aInit.nLoadDepth;
+    if (nDepth > 0) 
+    {
+        OSL_ENSURE(m_aTemplate.isEmpty() || m_aTemplate->isInstanceTypeKnown(),"ERROR: Need a type-validated template to fill a set");
+        OSL_ENSURE(aInit.aTemplateProvider.isValid() || m_aTemplate->isInstanceValue(), "ERROR: Need a template provider to fill a non-primitive set");
+
+        doInitElements(aInit.aTemplateProvider,m_rOriginal,childDepth(nDepth));
+        return true;
+    }
+    else
+        return false;
+}
+
+//-----------------------------------------------------------------------------
 void SetNodeImpl::initElements(TemplateProvider const& aTemplateProvider,TreeImpl& rParentTree,NodeOffset nPos,TreeDepth nDepth)
 {
     OSL_ENSURE(m_pParentTree == 0 || m_pParentTree == &rParentTree,	"WARNING: Set Node: Changing parent");
@@ -234,13 +366,11 @@ void SetNodeImpl::initElements(TemplateProvider const& aTemplateProvider,TreeImp
     m_pParentTree = &rParentTree;
     m_nContextPos = nPos;
 
+    OSL_ENSURE(!implHasLoadedElements(),"ERROR: Reinitializing set"); //doClearElements();
     OSL_ASSERT(doIsEmpty()); //doClearElements();
 
-    if (nDepth > 0) 
-    {
-        OSL_ENSURE(m_aTemplate.isEmpty() || m_aTemplate->isInstanceTypeKnown(),"ERROR: Need a type-validated template to fill a set");
-        doInitElements(aTemplateProvider,m_rOriginal,childDepth(nDepth));
-    }
+    if (nDepth > 0)
+        m_pInit.reset( new InitHelper(aTemplateProvider,nDepth) );
 }
 
 //-----------------------------------------------------------------------------
@@ -301,26 +431,26 @@ void ValueNodeImpl::setDefault()
 }
 //-----------------------------------------------------------------------------
             
-void ValueNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void ValueNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
     fetchInfo(rInfo,m_rOriginal);
     rInfo.aAttributes.bDefaultable = m_rOriginal.hasDefault();
 }
 //-----------------------------------------------------------------------------
 
-void ValueNodeImpl::setNodeName(Name const& aName)
+void ValueNodeImpl::doSetNodeName(Name const& aName)
 {
     m_rOriginal.setName(aName.toString());
 }
 //-----------------------------------------------------------------------------
 
-NodeType::Enum ValueNodeImpl::getType() const
+NodeType::Enum ValueNodeImpl::doGetType() const
 {
     return NodeType::eVALUE;
 }			
 //-----------------------------------------------------------------------------
 
-void ValueNodeImpl::dispatch(INodeHandler& rHandler)
+void ValueNodeImpl::doDispatch(INodeHandler& rHandler)
 {
     rHandler.handle(*this);
 }
@@ -330,14 +460,53 @@ void ValueNodeImpl::dispatch(INodeHandler& rHandler)
 // legacy commit
 //-----------------------------------------------------------------------------
 
-std::auto_ptr<SubtreeChange> SetNodeImpl::preCommitChanges()
+std::auto_ptr<SubtreeChange> SetNodeImpl::preCommitChanges() 
+{ 
+    // cannot have changes if elements not yet loaded
+    if (implHasLoadedElements())
+    {
+        return doPreCommitChanges();
+    }
+    else
+    {
+        OSL_ENSURE(!hasChanges(),"ERROR: Cannot have changes if elements haven't been loaded yet");
+        return std::auto_ptr<SubtreeChange>();
+    }
+}
+//-----------------------------------------------------------------------------
+
+void SetNodeImpl::finishCommit(SubtreeChange& rChanges) 
+{ 
+    // cannot have changes if elements not yet loaded
+    OSL_ENSURE(implHasLoadedElements(),"ERROR: Cannot have provided changes to be finished - set not yet loaded");
+    doFinishCommit(rChanges); 
+}
+//-----------------------------------------------------------------------------
+
+void SetNodeImpl::revertCommit(SubtreeChange& rChanges) 
+{ 
+    // cannot have changes if elements not yet loaded
+    OSL_ENSURE(implHasLoadedElements(),"ERROR: Cannot have provided changes to be reverted - set not yet loaded");
+    doRevertCommit(rChanges); 
+}
+//-----------------------------------------------------------------------------
+
+void SetNodeImpl::failedCommit(SubtreeChange& rChanges) 
+{
+    // cannot have changes if elements not yet loaded
+    OSL_ENSURE(implHasLoadedElements(),"ERROR: Cannot have provided changes that failed - set not yet loaded");
+    doFailedCommit(rChanges); 
+}
+//-----------------------------------------------------------------------------
+
+std::auto_ptr<SubtreeChange> SetNodeImpl::doPreCommitChanges()
 {
     OSL_ENSURE(!hasChanges(),"ERROR: Committing to an old changes tree is not supported on this node");
     return std::auto_ptr<SubtreeChange>();
 }
 //-----------------------------------------------------------------------------
 
-void SetNodeImpl::finishCommit(SubtreeChange& rChange)
+void SetNodeImpl::doFinishCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(rChange.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChange.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -347,7 +516,7 @@ void SetNodeImpl::finishCommit(SubtreeChange& rChange)
 }
 //-----------------------------------------------------------------------------
 
-void SetNodeImpl::revertCommit(SubtreeChange& rChange)
+void SetNodeImpl::doRevertCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(rChange.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChange.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -357,7 +526,7 @@ void SetNodeImpl::revertCommit(SubtreeChange& rChange)
 }
 //-----------------------------------------------------------------------------
 
-void SetNodeImpl::failedCommit(SubtreeChange& rChange)
+void SetNodeImpl::doFailedCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(rChange.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChange.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -376,40 +545,76 @@ void SetNodeImpl::doCollectChangesWithTarget(NodeChanges& rChanges, TreeImpl* pP
 }
 //-----------------------------------------------------------------------------
 
-void SetNodeImpl::adjustToChanges(NodeChanges& rLocalChanges, SubtreeChange const& rExternalChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth)
+void SetNodeImpl::adjustToChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth)
 {
     if (nDepth > 0)
     {
         OSL_ASSERT( aTemplateProvider.isValid() );
+        
+        if (implHasLoadedElements())
+        {
+            doAdjustToChanges(rLocalChanges, rExternalChange, aTemplateProvider, childDepth(nDepth));
+        }
+        else
+        {
+            OSL_ENSURE( !hasChanges(),"Cannot have changes to consider when no elements are loaded");
 
-        doAdjustToChanges(rLocalChanges, rExternalChange, aTemplateProvider, childDepth(nDepth));
+            implCollectChanges( rLocalChanges, rExternalChange, nDepth);
+        }
     }
 }
 //-----------------------------------------------------------------------------
 
+void SetNodeImpl::implCollectChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChange, 
+                                     TreeDepth nDepth)
+{
+    OSL_ASSERT(nDepth > 0);
+
+    if (TreeImpl* pParentTree = this->getParentTree())
+    {
+        NodeOffset nNode = getContextOffset();
+
+        OSL_ENSURE(pParentTree->isValidNode(nNode), "Invalid context node in Set");
+        OSL_ENSURE(&pParentTree->node(nNode)->setImpl() == this, "Wrong context node in Set");
+
+        CollectChanges aCollector(rLocalChanges, *pParentTree, nNode, nDepth);
+
+        aCollector.collectFrom(rExternalChange);
+    }
+    else
+        OSL_ENSURE(false, "Missing context tree in Set");
+}
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+std::auto_ptr<SubtreeChange> GroupNodeImpl::preCommitChanges() 
+{ 
+    return doPreCommitChanges(); 
+}
 //-----------------------------------------------------------------------------
-std::auto_ptr<SubtreeChange> GroupNodeImpl::preCommitChanges()
+
+std::auto_ptr<SubtreeChange> GroupNodeImpl::doPreCommitChanges()
 {
     OSL_ENSURE(!hasChanges(),"ERROR: Committing to an old changes tree is not supported on this node");
     return std::auto_ptr<SubtreeChange>();
 }
 //-----------------------------------------------------------------------------
 
-void GroupNodeImpl::finishCommit(SubtreeChange& rChange)
+void GroupNodeImpl::doFinishCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(!rChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
     OSL_ENSURE(!hasChanges(),"ERROR: Old-style commit not supported: changes are lost");
 }
 //-----------------------------------------------------------------------------
 
-void GroupNodeImpl::revertCommit(SubtreeChange& rChange)
+void GroupNodeImpl::doRevertCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(!rChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
     OSL_ENSURE(!hasChanges(),"ERROR: Old-style commit not supported: changes not restored");
 }
 //-----------------------------------------------------------------------------
 
-void GroupNodeImpl::failedCommit(SubtreeChange& rChange)
+void GroupNodeImpl::doFailedCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(!rChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
     OSL_ENSURE(!hasChanges(),"ERROR: Old-style commit not supported: changes not recovered");
@@ -423,26 +628,32 @@ void GroupNodeImpl::doCollectChangesWithTarget(NodeChanges& , TreeImpl* , NodeOf
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
-std::auto_ptr<ValueChange> ValueNodeImpl::preCommitChange()
+std::auto_ptr<ValueChange> ValueNodeImpl::preCommitChange() 
+{ 
+    return doPreCommitChange(); 
+}
+//-----------------------------------------------------------------------------
+
+std::auto_ptr<ValueChange> ValueNodeImpl::doPreCommitChange()
 {
     OSL_ENSURE(!hasChanges(),"ERROR: Committing to an old changes tree is not supported on this node");
     return std::auto_ptr<ValueChange>();
 }
 //-----------------------------------------------------------------------------
 
-void ValueNodeImpl::finishCommit(ValueChange& )
+void ValueNodeImpl::doFinishCommit(ValueChange& )
 {
     OSL_ENSURE(!hasChanges(),"ERROR: Old-style commit not supported: changes are lost");
 }
 //-----------------------------------------------------------------------------
 
-void ValueNodeImpl::revertCommit(ValueChange& )
+void ValueNodeImpl::doRevertCommit(ValueChange& )
 {
     OSL_ENSURE(!hasChanges(),"ERROR: Old-style commit not supported: changes not restored");
 }
 //-----------------------------------------------------------------------------
 
-void ValueNodeImpl::failedCommit(ValueChange& )
+void ValueNodeImpl::doFailedCommit(ValueChange& )
 {
     OSL_ENSURE(!hasChanges(),"ERROR: Old-style commit not supported: changes not recovered");
 }
@@ -467,13 +678,12 @@ NodeChangeImpl* ValueNodeImpl::doCollectChange() const
 //-----------------------------------------------------------------------------
 
 
-void ValueNodeImpl::adjustToChange(NodeChanges& rLocalChanges, ValueChange const& rExternalChange, TreeImpl& rParentTree, NodeOffset nPos)
+void ValueNodeImpl::adjustToChange(NodeChangesInformation& rLocalChanges, ValueChange const& rExternalChange, TreeImpl& rParentTree, NodeOffset nPos)
 {
     if (NodeChangeImpl* pThisChange = doAdjustToChange(rExternalChange))
     {
         pThisChange->setTarget(&rParentTree,nPos);
-
-        rLocalChanges.add( NodeChange(pThisChange) );
+        addLocalChangeHelper(rLocalChanges, NodeChange(pThisChange));
     }
     else 
         OSL_TRACE("WARNING: Configuration: derived class hides an external value change from listeners");
diff --git a/configmgr/source/treemgr/nodeimpl.hxx b/configmgr/source/treemgr/nodeimpl.hxx
index 15a2519f27..24db35fd68 100644
--- a/configmgr/source/treemgr/nodeimpl.hxx
+++ b/configmgr/source/treemgr/nodeimpl.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: nodeimpl.hxx,v $
  *
- *  $Revision: 1.5 $
+ *  $Revision: 1.6 $
  *
- *  last change: $Author: jb $ $Date: 2000-12-07 14:48:18 $
+ *  last change: $Author: jb $ $Date: 2001-02-13 17:20:54 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -63,7 +63,7 @@
 #define CONFIGMGR_CONFIGNODEBEHAVIOR_HXX_
 
 #ifndef __SGI_STL_MEMORY
-#include <stl/memory>
+#include <memory>
 #endif
 
 #include "apitypes.hxx"
@@ -98,7 +98,10 @@ namespace configmgr
 
         struct NodeInfo;
         class NodeChangeImpl;
+        class NodeChange;
+        class NodeChangeInformation;
         class NodeChanges;
+        class NodeChangesInformation;
 //-----------------------------------------------------------------------------
 
 // Specific types of nodes
@@ -128,23 +131,33 @@ namespace configmgr
             void collectChanges(NodeChanges& rChanges, TreeImpl* pParent, NodeOffset nNode)	const 
                 { doCollectChangesWithTarget(rChanges,pParent,nNode); }
 
-            bool hasChanges()					const { return doHasChanges(); }
-            void markChanged()						  { doMarkChanged(); }
-            void commitChanges()					  { doCommitChanges(); }
+            bool hasChanges()				const	{ return doHasChanges(); }
+            void markChanged()						{ doMarkChanged(); }
+            void commitChanges()					{ doCommitChanges(); }
 
             static void makeIndirect(NodeImplHolder&	aThis, bool bIndirect);
 
-            virtual NodeType::Enum	getType()						const = 0;
-            virtual void			getNodeInfo(NodeInfo& rInfo)	const = 0;
-            virtual void			setNodeName(Name const& rName)	 = 0;
-            virtual void			dispatch(INodeHandler& rHandler) = 0;
+            NodeType::Enum	getType()		  const	{ return doGetType(); }
+            void getNodeInfo(NodeInfo& rInfo) const	{ doGetNodeInfo(rInfo); }
+            void setNodeName(Name const& rName_)	{ doSetNodeName(rName_); }
+            void dispatch(INodeHandler& rHandler_)	{ doDispatch(rHandler_); }
 
         private:
+            virtual NodeType::Enum	doGetType()						const = 0;
+            virtual void			doGetNodeInfo(NodeInfo& rInfo_)	const = 0;
+            virtual void			doSetNodeName(Name const& rName_)	 = 0;
+            virtual void			doDispatch(INodeHandler& rHandler_) = 0;
+
             virtual bool doHasChanges()	const = 0;
             virtual void doCollectChangesWithTarget(NodeChanges& rChanges, TreeImpl* pParent, NodeOffset nNode) const = 0;
             virtual void doMarkChanged() = 0;
             virtual void doCommitChanges() = 0;
             virtual NodeImplHolder doCloneIndirect(bool bIndirect) = 0;
+
+        protected:
+            //helper for migration to new (info based) model for adjusting to changes
+            static void addLocalChangeHelper( NodeChangesInformation& rLocalChanges, NodeChange const& aChange);
+
         };
 
 //-----------------------------------------------------------------------------
@@ -160,21 +173,29 @@ namespace configmgr
             explicit GroupNodeImpl(ISubtree& rOriginal);
             explicit GroupNodeImpl(GroupNodeImpl& rOriginal); // only for makeIndirect
 
-        // NodeImpl implementation
-            virtual void			getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void			setNodeName(Name const& rName) = 0;
-            
-            virtual std::auto_ptr<SubtreeChange> preCommitChanges();
-            virtual void finishCommit(SubtreeChange& rChanges);
-            virtual void revertCommit(SubtreeChange& rChanges);
-            virtual void failedCommit(SubtreeChange& rChanges);
+            std::auto_ptr<SubtreeChange> preCommitChanges();
+            void finishCommit(SubtreeChange& rChanges) { doFinishCommit(rChanges); }
+            void revertCommit(SubtreeChange& rChanges) { doRevertCommit(rChanges); }
+            void failedCommit(SubtreeChange& rChanges) { doFailedCommit(rChanges); }
+
+        protected:
+            virtual std::auto_ptr<SubtreeChange> doPreCommitChanges();
+            virtual void doFinishCommit(SubtreeChange& rChanges);
+            virtual void doRevertCommit(SubtreeChange& rChanges);
+            virtual void doFailedCommit(SubtreeChange& rChanges);
 
         // MoreNodeImpl implementation - direct clients don't need it
-        private:
+        protected:
             virtual void doCollectChangesWithTarget(NodeChanges& rChanges, TreeImpl* pParent, NodeOffset nNode) const;
 
-            virtual NodeType::Enum	getType() const;
-            virtual void			dispatch(INodeHandler& rHandler);
+        // NodeImpl implementation
+            virtual void			doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void			doSetNodeName(Name const& rName) = 0;
+            
+        private:
+            virtual NodeType::Enum	doGetType() const;
+            virtual void			doDispatch(INodeHandler& rHandler);
+
         };
 
 //-----------------------------------------------------------------------------
@@ -204,35 +225,57 @@ namespace configmgr
             TemplateHolder	m_aTemplate;
             TreeImpl*		m_pParentTree;
             NodeOffset		m_nContextPos;
+
+            struct InitHelper;
+            std::auto_ptr<InitHelper> m_pInit;
         public:
+            /// construct a set node referring to rOriginal as data node with the given element-template
             explicit SetNodeImpl(ISubtree& rOriginal, Template* pTemplate);
+            /// 'Moving constructor': Constructs a set that takes the data from rOriginal, leaves rOriginal empty
             explicit SetNodeImpl(SetNodeImpl& rOriginal); // only for makeIndirect
 
-        // the following wiil be implemented by derived classes
-            bool		isEmpty() const					{ return doIsEmpty(); }
-            SetEntry	findElement(Name const& aName)	{ return doFindElement(aName); };
+        // the following willmostly  be implemented by derived classes (using the virtual equivalents)
+            /// does this set contain any elements (loads elements if needed)
+            bool		isEmpty();
+            /// does this set contain an element named <var>aName</var> (loads elements if needed)
+            SetEntry	findElement(Name const& aName);
+            /// does this set contain an element named <var>aName</var> (and is that element loaded ?)
+            SetEntry	findAvailableElement(Name const& aName);
 
-            void		insertElement(Name const& aName, SetEntry const& aNewEntry) { doInsertElement(aName,aNewEntry); }
-            void		removeElement(Name const& aName)							{ doRemoveElement(aName); }
+            /// insert a new entry into this set
+            void		insertElement(Name const& aName, SetEntry const& aNewEntry);
+            /// remove an existing entry into this set
+            void		removeElement(Name const& aName);
 
+            /// Initialize the set data: Set context information, and build the view (actually loading the elements may be deferred)
             void		initElements(TemplateProvider const& aTemplateProvider, TreeImpl& rParentTree, NodeOffset nPos, TreeDepth nDepth);
 
-            SetNodeVisitor::Result dispatchToElements(SetNodeVisitor& aVisitor)		{ return doDispatchToElements(aVisitor); }
+            /// Call <code>aVisitor.visit(aElement)</code> for each element in this set until SetNodeVisitor::DONE is returned. 
+            SetNodeVisitor::Result dispatchToElements(SetNodeVisitor& aVisitor);
 
+            /// Get the template that describes elements of this set
             TemplateHolder getElementTemplate() const { return m_aTemplate; }
 
-        // NodeImpl implementation
-            virtual void			getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void			setNodeName(Name const& rName) = 0;
-            virtual NodeType::Enum	getType() const;
+            /// Prepare committing the changes in this set and its descendants, if any - builds a SubtreeChange describing pending changes.
+            std::auto_ptr<SubtreeChange> preCommitChanges();
+            /// Finalize committing the changes - patch the original state wrapper, reset the pending changes
+            void finishCommit(SubtreeChange& rChanges);
+            /// Back out precommited changes - restore original state wrapper, rebuild the pending changes
+            void revertCommit(SubtreeChange& rChanges);
+            /// Fix up precommited changes after failure - try to detect failures, patch the original state wrapper, reset the pending changes
+            void failedCommit(SubtreeChange& rChanges);
 
-        // legacy commit - default is 'Not supported'
-            virtual std::auto_ptr<SubtreeChange> preCommitChanges();
-            virtual void finishCommit(SubtreeChange& rChanges);
-            virtual void revertCommit(SubtreeChange& rChanges);
-            virtual void failedCommit(SubtreeChange& rChanges);
+        // does not load elements:
+            /// Adjust the internal representation after external changes to the original data - build NodeChangeInformation objects for notification
+            void adjustToChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChanges, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
 
-            void adjustToChanges(NodeChanges& rLocalChanges, SubtreeChange const& rExternalChanges, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
+        // legacy commit - default is 'Not supported'
+        protected:
+            ~SetNodeImpl();
+            virtual std::auto_ptr<SubtreeChange>doPreCommitChanges();
+            virtual void doFinishCommit(SubtreeChange& rChanges);
+            virtual void doRevertCommit(SubtreeChange& rChanges);
+            virtual void doFailedCommit(SubtreeChange& rChanges);
         protected:
             TreeImpl*	getParentTree() const;
             NodeOffset	getContextOffset() const;
@@ -249,15 +292,29 @@ namespace configmgr
             virtual void		doInitElements(TemplateProvider const& aTemplateProvider, ISubtree& rTree, TreeDepth nDepth) = 0;
             virtual void		doClearElements() = 0;
 
-            virtual void		doAdjustToChanges(NodeChanges& rLocalChanges, SubtreeChange const& rExternalChanges, TemplateProvider const& aTemplateProvider, TreeDepth nDepth) = 0;
+            virtual void		doAdjustToChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChanges, TemplateProvider const& aTemplateProvider, TreeDepth nDepth) = 0;
 
             virtual SetNodeVisitor::Result doDispatchToElements(SetNodeVisitor& aVisitor) = 0;
 
             virtual void		doCollectChanges(NodeChanges& rChanges) const = 0;
-        // More NodeImpl implementation - direct clients don't need it
+
+        // NodeImpl implementation - direct clients don't need it
+        protected:
+            virtual void			doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void			doSetNodeName(Name const& rName) = 0;
+            virtual NodeType::Enum	doGetType() const;
+
         private:
             virtual void			doCollectChangesWithTarget(NodeChanges& rChanges, TreeImpl* pParent, NodeOffset nNode) const;
-            virtual void			dispatch(INodeHandler& rHandler);
+            virtual void			doDispatch(INodeHandler& rHandler);
+
+        protected:
+            bool implHasLoadedElements() const;
+        private:
+            bool implLoadElements();
+            void implEnsureElementsLoaded();
+            bool implInitElements(InitHelper const& aInit);
+            void implCollectChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChange, TreeDepth nDepth);
         };
 
 //-----------------------------------------------------------------------------
@@ -286,26 +343,32 @@ namespace configmgr
             virtual void	setValue(UnoAny const& aNewValue) = 0;
             virtual void	setDefault() = 0; 
             
-        // NodeImpl implementation
-            virtual void			getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void			setNodeName(Name const& rName) = 0;
-            virtual NodeType::Enum	getType() const;
-
         // legacy commit - default is 'Not supported'
-            virtual std::auto_ptr<ValueChange> preCommitChange();
-            virtual void finishCommit(ValueChange& rChange);
-            virtual void revertCommit(ValueChange& rChange);
-            virtual void failedCommit(ValueChange& rChange);
+            std::auto_ptr<ValueChange> preCommitChange();
+            void finishCommit(ValueChange& rChange) { doFinishCommit(rChange); }
+            void revertCommit(ValueChange& rChange) { doRevertCommit(rChange); }
+            void failedCommit(ValueChange& rChange) { doFailedCommit(rChange); }
 
-            void adjustToChange(NodeChanges& rLocalChanges, ValueChange const& rExternalChange, TreeImpl& rParentTree, NodeOffset nPos);
-        // More NodeImpl implementation - direct clients don't need it
+            void adjustToChange(NodeChangesInformation& rLocalChanges, ValueChange const& rExternalChange, TreeImpl& rParentTree, NodeOffset nPos);
         protected:
+            virtual std::auto_ptr<ValueChange> doPreCommitChange();
+            virtual void doFinishCommit(ValueChange& rChange);
+            virtual void doRevertCommit(ValueChange& rChange);
+            virtual void doFailedCommit(ValueChange& rChange);
+
+
+        protected:
+            virtual void			doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void			doSetNodeName(Name const& rName) = 0;
+
+        // NodeImpl implementation - direct clients don't need it
             virtual NodeChangeImpl* doAdjustToChange(ValueChange const& rExternalChange);
             virtual NodeChangeImpl* doCollectChange() const;
 
             virtual void doCollectChangesWithTarget(NodeChanges& rChanges, TreeImpl* pParent, NodeOffset nNode) const;
         private:
-            virtual void			dispatch(INodeHandler& rHandler);
+            virtual NodeType::Enum	doGetType() const;
+            virtual void			doDispatch(INodeHandler& rHandler);
         };
 //-----------------------------------------------------------------------------
 
diff --git a/configmgr/source/treemgr/nodeimplobj.cxx b/configmgr/source/treemgr/nodeimplobj.cxx
index 7429acc225..6c77624964 100644
--- a/configmgr/source/treemgr/nodeimplobj.cxx
+++ b/configmgr/source/treemgr/nodeimplobj.cxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: nodeimplobj.cxx,v $
  *
- *  $Revision: 1.8 $
+ *  $Revision: 1.9 $
  *
- *  last change: $Author: jb $ $Date: 2000-12-07 14:48:18 $
+ *  last change: $Author: jb $ $Date: 2001-02-13 17:20:54 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -133,15 +133,15 @@ void ReadOnlyValueNodeImpl::setDefault()
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyValueNodeImpl::setNodeName(Name const& )
+void ReadOnlyValueNodeImpl::doSetNodeName(Name const& )
 {
     failReadOnly();
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyValueNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void ReadOnlyValueNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    ValueNodeImpl::getNodeInfo(rInfo);
+    ValueNodeImpl::doGetNodeInfo(rInfo);
     rInfo.aAttributes.bWritable = false;
 }
 //-----------------------------------------------------------------------------
@@ -228,9 +228,9 @@ void DirectValueNodeImpl::setDefault()
 }
 //-----------------------------------------------------------------------------
 
-void DirectValueNodeImpl::setNodeName(Name const& aName)
+void DirectValueNodeImpl::doSetNodeName(Name const& aName)
 {
-    ValueNodeImpl::setNodeName(aName);
+    ValueNodeImpl::doSetNodeName(aName);
 }
 //-----------------------------------------------------------------------------
 
@@ -369,15 +369,15 @@ void DeferredValueNodeImpl::setDefault()
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void DeferredValueNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    ValueNodeImpl::getNodeInfo(rInfo);
+    ValueNodeImpl::doGetNodeInfo(rInfo);
     if (m_pNewName)
         rInfo.aName = *m_pNewName;
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueNodeImpl::setNodeName(Name const& aNewName)
+void DeferredValueNodeImpl::doSetNodeName(Name const& aNewName)
 {
     std::auto_ptr<Name> pNewName( new Name(aNewName) );
     delete m_pNewName;
@@ -454,14 +454,14 @@ void DeferredValueNodeImpl::doCommitChanges()
 
     if (m_pNewName)
     {
-        ValueNodeImpl::setNodeName(*m_pNewName);
+        ValueNodeImpl::doSetNodeName(*m_pNewName);
 
         delete m_pNewName, m_pNewName = 0;
     }
 }
 //-----------------------------------------------------------------------------
 
-std::auto_ptr<ValueChange> DeferredValueNodeImpl::preCommitChange()
+std::auto_ptr<ValueChange> DeferredValueNodeImpl::doPreCommitChange()
 {	
     OSL_ENSURE( !m_pNewName, "Renaming not supported with old changes !");
 
@@ -488,7 +488,7 @@ std::auto_ptr<ValueChange> DeferredValueNodeImpl::preCommitChange()
 
     // now get the name of this node
     NodeInfo aInfo;
-    getNodeInfo(aInfo);
+    doGetNodeInfo(aInfo);
 
     // now make a ValueChange
     ValueChange* pChange = new ValueChange( aInfo.aName.toString(), getValue(), 
@@ -498,7 +498,7 @@ std::auto_ptr<ValueChange> DeferredValueNodeImpl::preCommitChange()
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueNodeImpl::finishCommit(ValueChange& rChange)
+void DeferredValueNodeImpl::doFinishCommit(ValueChange& rChange)
 {
     OSL_ENSURE(rChange.getNewValue() == this->getValue(),"Committed change does not match the intended value");
 
@@ -509,14 +509,14 @@ void DeferredValueNodeImpl::finishCommit(ValueChange& rChange)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueNodeImpl::revertCommit(ValueChange& rChange)
+void DeferredValueNodeImpl::doRevertCommit(ValueChange& rChange)
 {
     OSL_ENSURE(rChange.getNewValue() == this->getValue(),"Reverted change does not match the intended value");
     OSL_ENSURE(doHasChanges(), "DeferredValueNodeImpl: No Changes to restore");
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueNodeImpl::failedCommit(ValueChange& rChange)
+void DeferredValueNodeImpl::doFailedCommit(ValueChange& rChange)
 {
     // discard the change
     delete m_pNewValue, m_pNewValue = 0;
@@ -547,15 +547,15 @@ NodeImplHolder DeferredValueNodeImpl::doCloneIndirect(bool bIndirect)
 // class ReadOnlyGroupNodeImpl
 //-----------------------------------------------------------------------------
 
-void ReadOnlyGroupNodeImpl::setNodeName(Name const& )
+void ReadOnlyGroupNodeImpl::doSetNodeName(Name const& )
 {
     failReadOnly();
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyGroupNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void ReadOnlyGroupNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    GroupNodeImpl::getNodeInfo(rInfo);
+    GroupNodeImpl::doGetNodeInfo(rInfo);
     rInfo.aAttributes.bWritable = false;
 }
 //-----------------------------------------------------------------------------
@@ -600,9 +600,9 @@ DirectGroupNodeImpl::DirectGroupNodeImpl(DeferredGroupNodeImpl& rOriginal)
 {}
 //-----------------------------------------------------------------------------
 
-void DirectGroupNodeImpl::setNodeName(Name const& rName)
+void DirectGroupNodeImpl::doSetNodeName(Name const& rName)
 {
-    GroupNodeImpl::setNodeName(rName);
+    GroupNodeImpl::doSetNodeName(rName);
 }
 //-----------------------------------------------------------------------------
 
@@ -659,15 +659,15 @@ DeferredGroupNodeImpl::~DeferredGroupNodeImpl()
 }
 //-----------------------------------------------------------------------------
 
-void DeferredGroupNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void DeferredGroupNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    GroupNodeImpl::getNodeInfo(rInfo);
+    GroupNodeImpl::doGetNodeInfo(rInfo);
     if (m_pNewName)
         rInfo.aName = *m_pNewName;
 }
 //-----------------------------------------------------------------------------
 
-void DeferredGroupNodeImpl::setNodeName(Name const& aNewName)
+void DeferredGroupNodeImpl::doSetNodeName(Name const& aNewName)
 {
     std::auto_ptr<Name> pNewName( new Name(aNewName) );
     delete m_pNewName;
@@ -694,14 +694,14 @@ void DeferredGroupNodeImpl::doCommitChanges()
 
     if (m_pNewName)
     {
-        GroupNodeImpl::setNodeName(*m_pNewName);
+        GroupNodeImpl::doSetNodeName(*m_pNewName);
 
         delete m_pNewName, m_pNewName = 0;
     }
 }
 //-----------------------------------------------------------------------------
 
-std::auto_ptr<SubtreeChange> DeferredGroupNodeImpl::preCommitChanges()
+std::auto_ptr<SubtreeChange> DeferredGroupNodeImpl::doPreCommitChanges()
 {	
     OSL_ENSURE( !m_pNewName, "Renaming not supported with old changes !");
 
@@ -711,7 +711,7 @@ std::auto_ptr<SubtreeChange> DeferredGroupNodeImpl::preCommitChanges()
     {
         // get the name of this node
         NodeInfo aInfo;
-        getNodeInfo(aInfo);
+        doGetNodeInfo(aInfo);
         aRet.reset( new SubtreeChange(aInfo.aName.toString(), 
                                       rtl::OUString(),
                                       aInfo.aAttributes) );
@@ -720,21 +720,21 @@ std::auto_ptr<SubtreeChange> DeferredGroupNodeImpl::preCommitChanges()
 }
 //-----------------------------------------------------------------------------
 
-void DeferredGroupNodeImpl::finishCommit(SubtreeChange& rChange)
+void DeferredGroupNodeImpl::doFinishCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(!rChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
     m_bChanged = false;
 }
 //-----------------------------------------------------------------------------
 
-void DeferredGroupNodeImpl::revertCommit(SubtreeChange& rChange)
+void DeferredGroupNodeImpl::doRevertCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(!rChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
     OSL_ENSURE(m_bChanged, "DeferredGroupNodeImpl: No Changes to restore");
 }
 //-----------------------------------------------------------------------------
 
-void DeferredGroupNodeImpl::failedCommit(SubtreeChange& rChange)
+void DeferredGroupNodeImpl::doFailedCommit(SubtreeChange& rChange)
 {
     OSL_ENSURE(!rChange.isSetNodeChange(),"ERROR: Change type SET does not match group");
     // discard the change
@@ -789,15 +789,15 @@ ReadOnlyTreeSetNodeImpl::Element ReadOnlyTreeSetNodeImpl::doMakeAdditionalElemen
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyTreeSetNodeImpl::setNodeName(Name const& )
+void ReadOnlyTreeSetNodeImpl::doSetNodeName(Name const& )
 {
     failReadOnly();
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyTreeSetNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void ReadOnlyTreeSetNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    TreeSetNodeImpl::getNodeInfo(rInfo);
+    TreeSetNodeImpl::doGetNodeInfo(rInfo);
     rInfo.aAttributes.bWritable = false;
 }
 //-----------------------------------------------------------------------------
@@ -859,15 +859,15 @@ ReadOnlyValueSetNodeImpl::Element ReadOnlyValueSetNodeImpl::doMakeAdditionalElem
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyValueSetNodeImpl::setNodeName(Name const& )
+void ReadOnlyValueSetNodeImpl::doSetNodeName(Name const& )
 {
     failReadOnly();
 }
 //-----------------------------------------------------------------------------
 
-void ReadOnlyValueSetNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void ReadOnlyValueSetNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    ValueSetNodeImpl::getNodeInfo(rInfo);
+    ValueSetNodeImpl::doGetNodeInfo(rInfo);
     rInfo.aAttributes.bWritable = false;
 }
 //-----------------------------------------------------------------------------
@@ -944,9 +944,9 @@ DirectTreeSetNodeImpl::Element DirectTreeSetNodeImpl::doMakeAdditionalElement(Ad
 }
 //-----------------------------------------------------------------------------
 
-void DirectTreeSetNodeImpl::setNodeName(Name const& aNewName)
+void DirectTreeSetNodeImpl::doSetNodeName(Name const& aNewName)
 {
-    TreeSetNodeImpl::setNodeName(aNewName);
+    TreeSetNodeImpl::doSetNodeName(aNewName);
 }
 //-----------------------------------------------------------------------------
 
@@ -1024,9 +1024,9 @@ DirectValueSetNodeImpl::Element DirectValueSetNodeImpl::doMakeAdditionalElement(
 }
 //-----------------------------------------------------------------------------
 
-void DirectValueSetNodeImpl::setNodeName(Name const& aName)
+void DirectValueSetNodeImpl::doSetNodeName(Name const& aName)
 {
-    ValueSetNodeImpl::setNodeName(aName);
+    ValueSetNodeImpl::doSetNodeName(aName);
 }
 //-----------------------------------------------------------------------------
 
@@ -1157,15 +1157,15 @@ SetNodeVisitor::Result DeferredTreeSetNodeImpl::doDispatchToElements(SetNodeVisi
 }
 //-----------------------------------------------------------------------------
 
-void DeferredTreeSetNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void DeferredTreeSetNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    TreeSetNodeImpl::getNodeInfo(rInfo);
+    TreeSetNodeImpl::doGetNodeInfo(rInfo);
     if (m_pNewName)
         rInfo.aName = *m_pNewName;
 }
 //-----------------------------------------------------------------------------
 
-void DeferredTreeSetNodeImpl::setNodeName(Name const& aNewName)
+void DeferredTreeSetNodeImpl::doSetNodeName(Name const& aNewName)
 {
     std::auto_ptr<Name> pNewName( new Name(aNewName) );
     delete m_pNewName;
@@ -1329,20 +1329,20 @@ void DeferredTreeSetNodeImpl::doCommitChanges()
 
     if (m_pNewName)
     {
-        TreeSetNodeImpl::setNodeName(*m_pNewName);
+        TreeSetNodeImpl::doSetNodeName(*m_pNewName);
 
         delete m_pNewName, m_pNewName = 0;
     }
 }
 //-----------------------------------------------------------------------------
 
-std::auto_ptr<SubtreeChange> DeferredTreeSetNodeImpl::preCommitChanges()
+std::auto_ptr<SubtreeChange> DeferredTreeSetNodeImpl::doPreCommitChanges()
 {	
     OSL_ENSURE( !m_pNewName, "Renaming not supported with old changes !");
 
     // nowfirst get the name of this node
     NodeInfo aInfo;
-    getNodeInfo(aInfo);
+    doGetNodeInfo(aInfo);
 
     // and make a SubtreeChange
     std::auto_ptr<SubtreeChange> pSetChange( new SubtreeChange(aInfo.aName.toString(), 															   
@@ -1410,7 +1410,7 @@ std::auto_ptr<SubtreeChange> DeferredTreeSetNodeImpl::preCommitChanges()
 }
 //-----------------------------------------------------------------------------
 
-void DeferredTreeSetNodeImpl::finishCommit(SubtreeChange& rChanges)
+void DeferredTreeSetNodeImpl::doFinishCommit(SubtreeChange& rChanges)
 {
     OSL_ENSURE(rChanges.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChanges.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -1497,7 +1497,7 @@ void DeferredTreeSetNodeImpl::finishCommit(SubtreeChange& rChanges)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredTreeSetNodeImpl::revertCommit(SubtreeChange& rChanges)
+void DeferredTreeSetNodeImpl::doRevertCommit(SubtreeChange& rChanges)
 {
     OSL_ENSURE(rChanges.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChanges.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -1567,7 +1567,7 @@ void DeferredTreeSetNodeImpl::revertCommit(SubtreeChange& rChanges)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredTreeSetNodeImpl::failedCommit(SubtreeChange& rChanges)
+void DeferredTreeSetNodeImpl::doFailedCommit(SubtreeChange& rChanges)
 {
     OSL_ENSURE(rChanges.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChanges.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -1738,7 +1738,7 @@ void DeferredTreeSetNodeImpl::implRemoveOldElement(Name const& aName)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredTreeSetNodeImpl::doAdjustChangedElement(NodeChanges& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider)
+void DeferredTreeSetNodeImpl::doAdjustChangedElement(NodeChangesInformation& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider)
 {
     if (Element* pLocalElement = m_aChangedData.getElement(aName))
     {
@@ -1748,7 +1748,7 @@ void DeferredTreeSetNodeImpl::doAdjustChangedElement(NodeChanges& rLocalChanges,
             Element aLocalElement = *pLocalElement;
 
             // also signal something happened
-            rLocalChanges.add( NodeChange( doCreateReplace(aName,aLocalElement,aLocalElement) ) );
+            addLocalChangeHelper(rLocalChanges, NodeChange( doCreateReplace(aName,aLocalElement,aLocalElement) ) );
         }
         else
         { 
@@ -1939,15 +1939,15 @@ SetNodeVisitor::Result DeferredValueSetNodeImpl::doDispatchToElements(SetNodeVis
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueSetNodeImpl::getNodeInfo(NodeInfo& rInfo) const
+void DeferredValueSetNodeImpl::doGetNodeInfo(NodeInfo& rInfo) const
 {
-    ValueSetNodeImpl::getNodeInfo(rInfo);
+    ValueSetNodeImpl::doGetNodeInfo(rInfo);
     if (m_pNewName)
         rInfo.aName = *m_pNewName;
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueSetNodeImpl::setNodeName(Name const& aNewName)
+void DeferredValueSetNodeImpl::doSetNodeName(Name const& aNewName)
 {
     std::auto_ptr<Name> pNewName( new Name(aNewName) );
     delete m_pNewName;
@@ -2109,20 +2109,20 @@ void DeferredValueSetNodeImpl::doCommitChanges()
 
     if (m_pNewName)
     {
-        ValueSetNodeImpl::setNodeName(*m_pNewName);
+        ValueSetNodeImpl::doSetNodeName(*m_pNewName);
 
         delete m_pNewName, m_pNewName = 0;
     }
 }
 //-----------------------------------------------------------------------------
 
-std::auto_ptr<SubtreeChange> DeferredValueSetNodeImpl::preCommitChanges()
+std::auto_ptr<SubtreeChange> DeferredValueSetNodeImpl::doPreCommitChanges()
 {	
     OSL_ENSURE( !m_pNewName, "Renaming not supported with old changes !");
 
     // nowfirst get the name of this node
     NodeInfo aInfo;
-    getNodeInfo(aInfo);
+    doGetNodeInfo(aInfo);
 
     // and make a SubtreeChange
     std::auto_ptr<SubtreeChange> pSetChange( new SubtreeChange(aInfo.aName.toString(), getElementTemplate()->getPath().toString(), aInfo.aAttributes) );			
@@ -2188,7 +2188,7 @@ std::auto_ptr<SubtreeChange> DeferredValueSetNodeImpl::preCommitChanges()
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueSetNodeImpl::finishCommit(SubtreeChange& rChanges)
+void DeferredValueSetNodeImpl::doFinishCommit(SubtreeChange& rChanges)
 {
     OSL_ENSURE(rChanges.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChanges.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -2275,7 +2275,7 @@ void DeferredValueSetNodeImpl::finishCommit(SubtreeChange& rChanges)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueSetNodeImpl::revertCommit(SubtreeChange& rChanges)
+void DeferredValueSetNodeImpl::doRevertCommit(SubtreeChange& rChanges)
 {
     OSL_ENSURE(rChanges.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChanges.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -2345,7 +2345,7 @@ void DeferredValueSetNodeImpl::revertCommit(SubtreeChange& rChanges)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueSetNodeImpl::failedCommit(SubtreeChange& rChanges)
+void DeferredValueSetNodeImpl::doFailedCommit(SubtreeChange& rChanges)
 {
     OSL_ENSURE(rChanges.isSetNodeChange(),"ERROR: Change type GROUP does not match set");
     OSL_ENSURE(	rChanges.getChildTemplateName() ==  getElementTemplate()->getPath().toString(),
@@ -2516,7 +2516,7 @@ void DeferredValueSetNodeImpl::implRemoveOldElement(Name const& aName)
 }
 //-----------------------------------------------------------------------------
 
-void DeferredValueSetNodeImpl::doAdjustChangedElement(NodeChanges& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider)
+void DeferredValueSetNodeImpl::doAdjustChangedElement(NodeChangesInformation& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider)
 {
     if (Element* pLocalElement = m_aChangedData.getElement(aName))
     {
@@ -2526,7 +2526,7 @@ void DeferredValueSetNodeImpl::doAdjustChangedElement(NodeChanges& rLocalChanges
             Element aLocalElement = *pLocalElement;
 
             // also signal something happened
-            rLocalChanges.add( NodeChange( doCreateReplace(aName,aLocalElement,aLocalElement) ) );
+            addLocalChangeHelper( rLocalChanges, NodeChange( doCreateReplace(aName,aLocalElement,aLocalElement) ) );
         }
         else
         { 
diff --git a/configmgr/source/treemgr/nodeimplobj.hxx b/configmgr/source/treemgr/nodeimplobj.hxx
index 87bc1f88f9..c4b8049bda 100644
--- a/configmgr/source/treemgr/nodeimplobj.hxx
+++ b/configmgr/source/treemgr/nodeimplobj.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: nodeimplobj.hxx,v $
  *
- *  $Revision: 1.5 $
+ *  $Revision: 1.6 $
  *
- *  last change: $Author: jb $ $Date: 2000-12-07 14:48:18 $
+ *  last change: $Author: jb $ $Date: 2001-02-13 17:20:54 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -64,7 +64,7 @@
 
 #include "nodeimpl.hxx"
 #include "setnodeimpl.hxx"
-#include <stl/memory>
+#include <memory>
 
 namespace configmgr
 {
@@ -96,11 +96,11 @@ namespace configmgr
             virtual void	setValue(UnoAny const& aNewValue);
             virtual void	setDefault(); 
             
+        protected:
         // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
 
-        protected:
             virtual bool doHasChanges()	const;
             virtual void doCommitChanges();
             virtual void doMarkChanged();
@@ -128,10 +128,10 @@ namespace configmgr
             virtual void	setValue(UnoAny const& aNewValue);
             virtual void	setDefault(); 
             
+        protected:
         // NodeImpl implementation
-            virtual	void setNodeName(Name const& rName);
+            virtual	void doSetNodeName(Name const& rName);
 
-        protected:
             virtual bool doHasChanges()	const;
             virtual void doCommitChanges();
             virtual void doMarkChanged();
@@ -159,19 +159,19 @@ namespace configmgr
             virtual void	setValue(UnoAny const& aNewValue);
             virtual void	setDefault(); 
             
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         protected:
         // legacy commit support
-            virtual std::auto_ptr<ValueChange> preCommitChange();
-            virtual void finishCommit(ValueChange& rChange);
-            virtual void revertCommit(ValueChange& rChange);
-            virtual void failedCommit(ValueChange& rChange);
+            virtual std::auto_ptr<ValueChange> doPreCommitChange();
+            virtual void doFinishCommit(ValueChange& rChange);
+            virtual void doRevertCommit(ValueChange& rChange);
+            virtual void doFailedCommit(ValueChange& rChange);
 
             virtual NodeChangeImpl* doAdjustToChange(ValueChange const& rExternalChange);
         protected:
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool doHasChanges()	const;
             virtual NodeChangeImpl* doCollectChange() const;
             virtual void doCommitChanges();
@@ -197,12 +197,12 @@ namespace configmgr
             : GroupNodeImpl(rOriginal)
             {}
 
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         // Base obverrideables
         private:
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool doHasChanges() const;
             virtual void doCommitChanges();
             virtual void doMarkChanged();
@@ -220,11 +220,11 @@ namespace configmgr
             explicit 
             DirectGroupNodeImpl(DeferredGroupNodeImpl& rOriginal);
 
-        // NodeImpl implementation
-            virtual	void setNodeName(Name const& rName);
-
         // Base obverrideables
         private:
+        // NodeImpl implementation
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool doHasChanges() const;
             virtual void doCommitChanges();
             virtual void doMarkChanged();
@@ -242,19 +242,19 @@ namespace configmgr
 
             ~DeferredGroupNodeImpl();
 
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         protected:
         // legacy commit support
-            virtual std::auto_ptr<SubtreeChange> preCommitChanges();
-            virtual void finishCommit(SubtreeChange& rChange);
-            virtual void revertCommit(SubtreeChange& rChange);
-            virtual void failedCommit(SubtreeChange& rChange);
+            virtual std::auto_ptr<SubtreeChange> doPreCommitChanges();
+            virtual void doFinishCommit(SubtreeChange& rChange);
+            virtual void doRevertCommit(SubtreeChange& rChange);
+            virtual void doFailedCommit(SubtreeChange& rChange);
 
         // Base obverrideables
         private:
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool doHasChanges() const;
             virtual void doCollectChangesWithTarget(NodeChanges& rChanges, TreeImpl* pParent, NodeOffset nNode) const;
             virtual void doCommitChanges();
@@ -278,12 +278,12 @@ namespace configmgr
             {}
 
 
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         // Base Overrideables
         private:
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual void doInsertElement(Name const& aName, SetEntry const& aNewEntry);
             virtual void doRemoveElement(Name const& aName);
 
@@ -307,10 +307,6 @@ namespace configmgr
             {}
 
 
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         // Base Overrideables
         private:
             virtual void doInsertElement(Name const& aName,  SetEntry const& aNewEntry);
@@ -319,6 +315,10 @@ namespace configmgr
             virtual void doInitElements(TemplateProvider const& aTemplateProvider, ISubtree& rTree, TreeDepth nDepth);
             virtual Element doMakeAdditionalElement(AddNode const& aAddNodeChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
 
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool doHasChanges() const;
             virtual void doCollectChanges(NodeChanges& rChanges) const;
             virtual void doCommitChanges();
@@ -338,11 +338,11 @@ namespace configmgr
             DirectTreeSetNodeImpl(DeferredTreeSetNodeImpl& rOriginal);
 
 
-        // NodeImpl implementation
-            virtual	void setNodeName(Name const& rName);
-
         // Base Overrideables
         private:
+        // NodeImpl implementation
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual void doInsertElement(Name const& aName, SetEntry const& aNewEntry);
             virtual void doRemoveElement(Name const& aName);
 
@@ -367,11 +367,11 @@ namespace configmgr
             explicit 
             DirectValueSetNodeImpl(DeferredValueSetNodeImpl& rOriginal);
 
-        // NodeImpl implementation
-            virtual	void setNodeName(Name const& rName);
-
         // Base Overrideables
         private:
+        // NodeImpl implementation
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual void doInsertElement(Name const& aName,  SetEntry const& aNewEntry);
             virtual void doRemoveElement(Name const& aName);
 
@@ -395,19 +395,19 @@ namespace configmgr
             DeferredTreeSetNodeImpl(DirectTreeSetNodeImpl& rOriginal);
 
 
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         protected:
         // legacy commit support
-            virtual std::auto_ptr<SubtreeChange> preCommitChanges();
-            virtual void finishCommit(SubtreeChange& rChanges);
-            virtual void revertCommit(SubtreeChange& rChanges);
-            virtual void failedCommit(SubtreeChange& rChanges);
+            virtual std::auto_ptr<SubtreeChange> doPreCommitChanges();
+            virtual void doFinishCommit(SubtreeChange& rChanges);
+            virtual void doRevertCommit(SubtreeChange& rChanges);
+            virtual void doFailedCommit(SubtreeChange& rChanges);
 
         // Base Overrideables
         private:
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool		doIsEmpty() const;
             virtual SetEntry	doFindElement(Name const& aName) ;
             virtual void		doClearElements();
@@ -419,7 +419,7 @@ namespace configmgr
             virtual void doInitElements(TemplateProvider const& aTemplateProvider, ISubtree& rTree, TreeDepth nDepth);
             virtual Element doMakeAdditionalElement(AddNode const& aAddNodeChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
 
-            virtual void doAdjustChangedElement(NodeChanges& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider);
+            virtual void doAdjustChangedElement(NodeChangesInformation& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider);
 
             virtual NodeChangeImpl* doAdjustToAddedElement(Name const& aName, AddNode const& aAddNodeChange, Element const& aNewElement);
             virtual NodeChangeImpl* doAdjustToRemovedElement(Name const& aName, RemoveNode const& aRemoveNodeChange);
@@ -451,19 +451,19 @@ namespace configmgr
             DeferredValueSetNodeImpl(DirectValueSetNodeImpl& rOriginal);
 
 
-        // NodeImpl implementation
-            virtual void getNodeInfo(NodeInfo& rInfo) const;
-            virtual	void setNodeName(Name const& rName);
-
         protected:
         // legacy commit support
-            virtual std::auto_ptr<SubtreeChange> preCommitChanges();
-            virtual void finishCommit(SubtreeChange& rChanges);
-            virtual void revertCommit(SubtreeChange& rChanges);
-            virtual void failedCommit(SubtreeChange& rChanges);
+            virtual std::auto_ptr<SubtreeChange> doPreCommitChanges();
+            virtual void doFinishCommit(SubtreeChange& rChanges);
+            virtual void doRevertCommit(SubtreeChange& rChanges);
+            virtual void doFailedCommit(SubtreeChange& rChanges);
 
         // Base Overrideables
         private:
+        // NodeImpl implementation
+            virtual void doGetNodeInfo(NodeInfo& rInfo) const;
+            virtual	void doSetNodeName(Name const& rName);
+
             virtual bool		doIsEmpty() const;
             virtual SetEntry	doFindElement(Name const& aName) ;
             virtual void		doClearElements();
@@ -475,7 +475,7 @@ namespace configmgr
             virtual void doInitElements(TemplateProvider const& aTemplateProvider, ISubtree& rTree, TreeDepth nDepth);
             virtual Element doMakeAdditionalElement(AddNode const& aAddNodeChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
 
-            virtual void doAdjustChangedElement(NodeChanges& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider);
+            virtual void doAdjustChangedElement(NodeChangesInformation& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider);
 
             virtual NodeChangeImpl* doAdjustToAddedElement(Name const& aName, AddNode const& aAddNodeChange, Element const& aNewElement);
             virtual NodeChangeImpl* doAdjustToRemovedElement(Name const& aName, RemoveNode const& aRemoveNodeChange);
diff --git a/configmgr/source/treemgr/setnodeimpl.cxx b/configmgr/source/treemgr/setnodeimpl.cxx
index 33e6e5b0fb..0c69fb28b7 100644
--- a/configmgr/source/treemgr/setnodeimpl.cxx
+++ b/configmgr/source/treemgr/setnodeimpl.cxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: setnodeimpl.cxx,v $
  *
- *  $Revision: 1.7 $
+ *  $Revision: 1.8 $
  *
- *  last change: $Author: dg $ $Date: 2000-11-30 08:20:25 $
+ *  last change: $Author: jb $ $Date: 2001-02-13 17:20:54 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -362,7 +362,7 @@ void AbstractSetNodeImpl::implInitElement(Element const& aNewElement)
 }
 //-------------------------------------------------------------------------
             
-void AbstractSetNodeImpl::doAdjustToChanges(NodeChanges& rLocalChanges, SubtreeChange const& rExternalChanges, 
+void AbstractSetNodeImpl::doAdjustToChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChanges, 
                                             TemplateProvider const& aTemplateProvider, TreeDepth nDepth)
 {
     for (SubtreeChange::ChildIterator it = rExternalChanges.begin(); it != rExternalChanges.end(); ++it)
@@ -372,8 +372,10 @@ void AbstractSetNodeImpl::doAdjustToChanges(NodeChanges& rLocalChanges, SubtreeC
 }
 //-------------------------------------------------------------------------
 
-void AbstractSetNodeImpl::implAdjustToElementChange(NodeChanges& rLocalChanges, Change const& aChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth)
+void AbstractSetNodeImpl::implAdjustToElementChange(NodeChangesInformation& rLocalChanges, Change const& aChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth)
 {
+    OSL_ENSURE( implHasLoadedElements() , "Unexpected call: Processing element change in uninitialized set");
+
     Name aName( aChange.getNodeName(), Name::NoValidate() );
 
     NodeChangeImpl* pThisChange = 0;
@@ -406,14 +408,14 @@ void AbstractSetNodeImpl::implAdjustToElementChange(NodeChanges& rLocalChanges,
 
     if (pThisChange)
     {
-        rLocalChanges.add( NodeChange(pThisChange) );
+        addLocalChangeHelper( rLocalChanges, NodeChange(pThisChange) );
     }
 }
 
 // Default implementations
 //-------------------------------------------------------------------------
 
-void AbstractSetNodeImpl::doAdjustChangedElement(NodeChanges& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider)
+void AbstractSetNodeImpl::doAdjustChangedElement(NodeChangesInformation& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider)
 {
     if (Element* pElement = getStoredElement(aName))
     {
@@ -728,13 +730,13 @@ ElementTreeHolder ValueSetNodeImpl::makeAdditionalElement(TemplateProvider const
 }
 //-------------------------------------------------------------------------
 
-NodeType::Enum TreeSetNodeImpl::getType() const
+NodeType::Enum TreeSetNodeImpl::doGetType() const
 {
     return NodeType::eTREESET;
 }
 //-------------------------------------------------------------------------
 
-NodeType::Enum	ValueSetNodeImpl::getType() const
+NodeType::Enum	ValueSetNodeImpl::doGetType() const
 {
     return NodeType::eVALUESET;
 }
diff --git a/configmgr/source/treemgr/setnodeimpl.hxx b/configmgr/source/treemgr/setnodeimpl.hxx
index 1966ac5004..07ad3bfa5c 100644
--- a/configmgr/source/treemgr/setnodeimpl.hxx
+++ b/configmgr/source/treemgr/setnodeimpl.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: setnodeimpl.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: jb $ $Date: 2000-11-20 01:38:19 $
+ *  last change: $Author: jb $ $Date: 2001-02-13 17:20:54 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -66,7 +66,7 @@
 #include "treeimpl.hxx"
 
 #include <vos/ref.hxx>
-#include <stl/map>
+#include <map>
 
 namespace configmgr
 {
@@ -187,7 +187,7 @@ namespace configmgr
 
             void		doClearElements();
 
-            void		doAdjustToChanges(NodeChanges& rLocalChanges, SubtreeChange const& rExternalChanges, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
+            void		doAdjustToChanges(NodeChangesInformation& rLocalChanges, SubtreeChange const& rExternalChanges, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
 
             SetNodeVisitor::Result doDispatchToElements(SetNodeVisitor& aVisitor);
 
@@ -198,12 +198,12 @@ namespace configmgr
             void	implInitElement(Element const& aNewElement); 
             void	implMakeIndirect(bool bIndirect); // ensures kids are (in)direct
 
-            void implAdjustToElementChange(NodeChanges& rLocalChanges, Change const& aChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
+            void implAdjustToElementChange(NodeChangesInformation& rLocalChanges, Change const& aChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth);
             
         // new overrideables
             virtual Element doMakeAdditionalElement(AddNode const& aAddNodeChange, TemplateProvider const& aTemplateProvider, TreeDepth nDepth) = 0;
 
-            virtual void doAdjustChangedElement(NodeChanges& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider);
+            virtual void doAdjustChangedElement(NodeChangesInformation& rLocalChanges, Name const& aName, Change const& aChange, TemplateProvider const& aTemplateProvider);
 
             virtual NodeChangeImpl* doAdjustToAddedElement(Name const& aName, AddNode const& aAddNodeChange, Element const& aNewElement);
             virtual NodeChangeImpl* doAdjustToRemovedElement(Name const& aName, RemoveNode const& aRemoveNodeChange);
@@ -241,7 +241,7 @@ namespace configmgr
 
         // base class implementation (or helpers)
         protected:
-            NodeType::Enum	getType() const;
+            NodeType::Enum	doGetType() const;
 
             void doInsertElement(Name const& aName, SetEntry const& aNewEntry) = 0;
             void doRemoveElement(Name const& aName) = 0;
@@ -263,7 +263,7 @@ namespace configmgr
 
         // base class implementations (or helpers)
         protected:
-            NodeType::Enum	getType() const;
+            NodeType::Enum	doGetType() const;
 
             void doInsertElement(Name const& aName, SetEntry const& aNewEntry) = 0;
             void doRemoveElement(Name const& aName) = 0;