diff options
Diffstat (limited to 'configmgr/source/treemgr/treeimpl.cxx')
| -rw-r--r-- | configmgr/source/treemgr/treeimpl.cxx | 1373 |
1 files changed, 0 insertions, 1373 deletions
diff --git a/configmgr/source/treemgr/treeimpl.cxx b/configmgr/source/treemgr/treeimpl.cxx deleted file mode 100644 index 66b26092e5e4..000000000000 --- a/configmgr/source/treemgr/treeimpl.cxx +++ /dev/null @@ -1,1373 +0,0 @@ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2008 by Sun Microsystems, Inc. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * $RCSfile: treeimpl.cxx,v $ - * $Revision: 1.33 $ - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_configmgr.hxx" -#include <stdio.h> -#include "anynoderef.hxx" -#include "builddata.hxx" -#include "configset.hxx" -#include "tracer.hxx" -#include "tree.hxx" -#include "roottreeimpl.hxx" -#include "nodeimpl.hxx" -#include "nodechange.hxx" -#include "nodechangeimpl.hxx" -#include "noderef.hxx" -#include "template.hxx" -#include "nodevisitor.hxx" -#include "valueref.hxx" -#include "valuenode.hxx" -#include "change.hxx" -#include "valuenodeimpl.hxx" -#include "setnodeimpl.hxx" -#include "groupnodeimpl.hxx" -#include "viewaccess.hxx" -#include "viewfactory.hxx" -#include "nodefactory.hxx" -#include <osl/diagnose.h> - -namespace configmgr -{ -//----------------------------------------------------------------------------- - namespace configuration - { -//----------------------------------------------------------------------------- -// class TreeImplBuilder - friend of Tree -//----------------------------------------------------------------------------- - -/** is a visitor-style algorithm to construct a <type>Tree::NodeList</type> - representing a configuration hierarchy -*/ -class TreeImplBuilder : public data::NodeVisitor -{ -public: - /** constructs a TreeImplBuilder to append onto <var>rList</var> - the products of <var>rFactory</var> up to depth <var>nDepth</var> - */ - TreeImplBuilder( - TemplateProvider const& aTemplateProvider, - rtl::Reference<view::ViewStrategy> const& _xStrategy, - Tree& rTree - ) - : m_xStrategy(_xStrategy) - , m_aTemplateProvider(aTemplateProvider) - , m_rFactory(_xStrategy->getNodeFactory()) - , m_rTree(rTree) - , m_nParent(0) - , m_nDepthLeft(rTree.m_nDepth) - { - OSL_ASSERT(m_rTree.m_aNodes.empty()); - OSL_DEBUG_ONLY(m_bMemberCheck = false); - m_rTree.m_xStrategy = _xStrategy; - } - -private: - using NodeVisitor::handle; - - virtual bool handle(sharable::ValueNode * node); - - virtual bool handle(sharable::GroupNode * node); - - virtual bool handle(sharable::SetNode * node); - - /// add a Node for group node <var>_aGroup</var> to the list - void addGroup(sharable::GroupNode * group); - /// add a Node for set node <var>_aSet</var> to the list - void addSet(sharable::SetNode * set); - /// add a Node for value node <var>rValue</var> to the list - void addValueElement(sharable::ValueNode * value); - /// add a Member for value node <var>rValue</var> to the list - void addValueMember(sharable::ValueNode * value); - - rtl::Reference<view::ViewStrategy> m_xStrategy; - TemplateProvider m_aTemplateProvider; - view::NodeFactory& m_rFactory; - Tree& m_rTree; - unsigned int m_nParent; - unsigned int m_nDepthLeft; -#if OSL_DEBUG_LEVEL > 0 - bool m_bMemberCheck; -#endif -}; -//----------------------------------------------------------------------------- - -bool TreeImplBuilder::handle(sharable::ValueNode * node) -{ - if (m_nParent == 0) - addValueElement(node); // if it is the root it is a value set element - else - addValueMember(node); // if it is not the root it is a group member - - return false; -} -//----------------------------------------------------------------------------- - -bool TreeImplBuilder::handle(sharable::GroupNode * node) -{ - addGroup(node); - return false; -} -//----------------------------------------------------------------------------- - -bool TreeImplBuilder::handle(sharable::SetNode * node) -{ - addSet(node); - return false; -} -//----------------------------------------------------------------------------- - -void TreeImplBuilder::addValueElement(sharable::ValueNode * value) -{ - rtl::Reference<NodeImpl> aValueNode( m_rFactory.makeValueNode(value) ); - OSL_ENSURE( aValueNode.is(), "could not make value node wrapper" ); - - OSL_ENSURE( m_nParent == 0, "Adding value element that is not root of its fragment" ); - // TODO:!isValid() => maybe substitute a SimpleValueNodeImpl if possible - if( aValueNode.is() ) - { - m_rTree.m_aNodes.push_back( NodeData(aValueNode, value->info.getName(), m_nParent) ); - } -} -//----------------------------------------------------------------------------- - -void TreeImplBuilder::addValueMember(sharable::ValueNode *) -{ - // nothing to do - OSL_DEBUG_ONLY(m_bMemberCheck = true); -} -//----------------------------------------------------------------------------- - -void TreeImplBuilder::addGroup(sharable::GroupNode * group) -{ - rtl::Reference<NodeImpl> aGroupNode( m_rFactory.makeGroupNode(group) ); - OSL_ENSURE( aGroupNode.is(), "could not make group node wrapper" ); - - // TODO:!isValid() => maybe substitute a SimpleValueNodeImpl if possible - if( aGroupNode.is() ) - { - m_rTree.m_aNodes.push_back( NodeData(aGroupNode,group->info.getName(),m_nParent) ); - - // now fill in group members - if (m_nDepthLeft > 0) - { - unsigned int nSaveParent = m_nParent; - decDepth(m_nDepthLeft); - - m_nParent = m_rTree.m_aNodes.size() + Tree::ROOT - 1; - - #if OSL_DEBUG_LEVEL > 0 - bool bSaveMemberCheck = m_bMemberCheck; - m_bMemberCheck = false; - #endif - - // now recurse: - this->visitChildren(group); - - OSL_ENSURE(m_nParent < m_rTree.m_aNodes.size() || m_bMemberCheck, - "WARNING: Configuration: Group within requested depth has no members"); - - OSL_DEBUG_ONLY(m_bMemberCheck = bSaveMemberCheck); - - incDepth(m_nDepthLeft); - m_nParent = nSaveParent; - } - } -} -//----------------------------------------------------------------------------- - -void TreeImplBuilder::addSet(sharable::SetNode * set) -{ - rtl::Reference<Template> aTemplate = makeSetElementTemplate(set, m_aTemplateProvider); - OSL_ASSERT(aTemplate.is()); - OSL_ENSURE(aTemplate->isInstanceTypeKnown(),"ERROR: Cannor create set instance without knowing the instance type"); - - rtl::Reference<NodeImpl> aSetNode( m_rFactory.makeSetNode(set, aTemplate.get()) ); - OSL_ENSURE( aSetNode.is(), "could not make set node wrapper" ); - - // TODO:!isValid() => maybe substitute a SimpleValueNodeImpl if possible - if( aSetNode.is() ) - { - m_rTree.m_aNodes.push_back( NodeData(aSetNode, set->info.getName(), m_nParent) ); - - // this also relies on one based offsets - unsigned int nNodeAdded = m_rTree.m_aNodes.size() + Tree::ROOT - 1; - - OSL_ASSERT(&m_rTree.m_aNodes.back().nodeImpl() == aSetNode.get()); - static_cast<SetNodeImpl&>(*aSetNode).initElements(m_aTemplateProvider, m_rTree, nNodeAdded, m_nDepthLeft); - } -} - -namespace { - class FindNonDefaultElement: public SetNodeVisitor { - public: - static bool hasNonDefaultElement( - view::ViewTreeAccess const & view, view::SetNode const & set) - { - FindNonDefaultElement visitor; - return view.dispatchToElements(set, visitor) == DONE; - } - - protected: - virtual Result visit(SetEntry const & entry) { - OSL_ASSERT(entry.isValid()); - rtl::Reference< Tree > tree(entry.tree()); - OSL_ASSERT(tree.is()); - node::Attributes atts(tree->getAttributes(tree->getRootNode())); - // A set element is considered default iff it is not replaced/added: - bool dflt = !atts.isReplacedForUser(); - return dflt ? CONTINUE : DONE; - } - }; - - class SetVisitorAdapter: public SetNodeVisitor { - public: - explicit SetVisitorAdapter(NodeVisitor & visitor): m_visitor(visitor) {} - - protected: - virtual Result visit(SetEntry const & entry) { - OSL_ASSERT(entry.isValid()); - rtl::Reference< Tree > tree(entry.tree()); - if (tree.is()) { - OSL_ASSERT( - Result(NodeVisitor::DONE) == SetNodeVisitor::DONE && - Result(NodeVisitor::CONTINUE) == SetNodeVisitor::CONTINUE); - return Result(tree->visit(tree->getRootNode(), m_visitor)); - } else { - return CONTINUE; - } - } - - private: - NodeVisitor & m_visitor; - }; - - class GroupVisitorAdapter: public GroupMemberVisitor { - public: - GroupVisitorAdapter( - rtl::Reference< Tree > const & parentTree, - NodeRef const & parentNode, NodeVisitor & visitor): - m_parentTree(parentTree), m_parentPos(parentNode.getOffset()), - m_visitor(visitor) - { - OSL_ASSERT( - !isEmpty(parentTree.get()) && parentNode.isValid() && - parentTree->isValidNode(parentNode.getOffset())); - } - - protected: - virtual Result visit(ValueMemberNode const & value) { - OSL_ASSERT( - value.isValid() && - Result(NodeVisitor::DONE) == GroupMemberVisitor::DONE && - Result(NodeVisitor::CONTINUE) == GroupMemberVisitor::CONTINUE); - return Result( - m_parentTree->visit( - ValueRef(value.getNodeName(), m_parentPos), m_visitor)); - } - - private: - rtl::Reference< Tree > m_parentTree; - unsigned int m_parentPos; - NodeVisitor & m_visitor; - }; -} - -//----------------------------------------------------------------------------- -// class NodeData -//----------------------------------------------------------------------------- - -NodeData::NodeData(rtl::Reference<NodeImpl> const& aSpecificNode, rtl::OUString const& aName, unsigned int nParent) -: m_pSpecificNode(aSpecificNode) -, m_aName_(aName) -, m_nParent(nParent) -{ -} - -//----------------------------------------------------------------------------- - -void NodeData::rebuild(rtl::Reference<view::ViewStrategy> const & _xNewStrategy, sharable::Node * newData) -{ - rtl::Reference<NodeImpl> aNewImpl; - if (this->isSetNode()) - { - sharable::SetNode * newSet = newData == 0 ? 0 : newData->setData(); - aNewImpl = _xNewStrategy->getNodeFactory().makeSetNode(newSet, 0); - - SetNodeImpl & rOldSetData = this->setImpl(); - SetNodeImpl & rNewSetData = static_cast<SetNodeImpl &>(*aNewImpl); - - rNewSetData.rebuildFrom(rOldSetData, newSet); - } - else if (this->isGroupNode()) - aNewImpl = _xNewStrategy->getNodeFactory().makeGroupNode(newData == 0 ? 0 : newData->groupData()); - - else if (this->isValueElementNode()) - aNewImpl = _xNewStrategy->getNodeFactory().makeValueNode(newData == 0 ? 0 : newData->valueData()); - - m_pSpecificNode = aNewImpl; -} - -//----------------------------------------------------------------------------- - -bool NodeData::isSetNode() const -{ - sharable::Node * node = getOriginalNodeAccess(); - return node != 0 && node->isSet(); -} -//----------------------------------------------------------------------------- - -bool NodeData::isValueElementNode() const -{ - sharable::Node * node = getOriginalNodeAccess(); - return node != 0 && node->isValue(); -} -//----------------------------------------------------------------------------- - -bool NodeData::isGroupNode() const -{ - sharable::Node * node = getOriginalNodeAccess(); - return node != 0 && node->isGroup(); -} -//----------------------------------------------------------------------------- - -SetNodeImpl& NodeData::implGetSetImpl() const -{ - OSL_ASSERT(m_pSpecificNode != 0); - OSL_ASSERT(isSetNode()); - - if (!isSetNode()) - throw Exception( "INTERNAL ERROR: Node is not a set node. Cast failing." ); - - return static_cast<SetNodeImpl&>(*m_pSpecificNode); -} -//--------------------------------------------------------------------- - -GroupNodeImpl& NodeData::implGetGroupImpl() const -{ - OSL_ASSERT(m_pSpecificNode != 0); - OSL_ASSERT(isGroupNode()); - - if (!isGroupNode()) - throw Exception( "INTERNAL ERROR: Node is not a group node. Cast failing." ); - - return static_cast<GroupNodeImpl&>(*m_pSpecificNode); -} -//--------------------------------------------------------------------- - -ValueElementNodeImpl& NodeData::implGetValueImpl() const -{ - OSL_ASSERT(m_pSpecificNode != 0); - OSL_ASSERT(isValueElementNode()); - - if (!isValueElementNode()) - throw Exception( "INTERNAL ERROR: Node is not a value node. Cast failing." ); - - return static_cast<ValueElementNodeImpl&>(*m_pSpecificNode); -} - -sharable::Node * NodeData::getOriginalNodeAccess() const -{ - return m_pSpecificNode->getOriginalNodeAccess(); -} - -NodeImpl & NodeData::implGetNodeImpl() const -{ - OSL_ASSERT(m_pSpecificNode != 0); - return *m_pSpecificNode; -} - -//----------------------------------------------------------------------------- - -//----------------------------------------------------------------------------- -// class Tree -//----------------------------------------------------------------------------- - -/// creates a Tree for a detached, virgin instance of <var>aTemplate</var> -Tree::Tree( ) -: m_aNodes() -, m_pParentTree(0) -, m_nParentNode(0) -, m_nDepth(0) -{ -} -//----------------------------------------------------------------------------- - -Tree::Tree( Tree& rParentTree, unsigned int nParentNode ) -: m_aNodes() -, m_pParentTree(&rParentTree) -, m_nParentNode(nParentNode) -, m_nDepth(0) -{ -} -//----------------------------------------------------------------------------- - -Tree::~Tree() -{ -} -//----------------------------------------------------------------------------- - -void Tree::disposeData() -{ - m_aNodes.clear(); -} - -bool Tree::isRootNode(NodeRef const & node) const { - OSL_ASSERT( - nodeCount() != 0 && (!node.isValid() || isValidNode(node.getOffset()))); - return node.isValid() && node.getOffset() == ROOT; -} - -NodeRef Tree::getRootNode() const { - OSL_ASSERT(nodeCount() != 0); - return NodeRef(ROOT, m_nDepth); -} - -NodeRef Tree::getContextNodeRef() const { - OSL_ASSERT(nodeCount() != 0 && (m_pParentTree == 0 || m_nParentNode != 0)); - return m_pParentTree == 0 - ? NodeRef() : m_pParentTree->getNode(m_nParentNode); -} - -bool Tree::isValidValueNode(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0); - if (!(value.isValid() && - value.checkValidState() && - isValidNode(value.m_nParentPos) && - view::ViewTreeAccess(this).isGroupNodeAt(value.m_nParentPos) && - getMemberNode(value).isValid())) - { - return false; - } - OSL_ASSERT(value.m_sNodeName.getLength() != 0); // old value handling? - return true; -} - -#if OSL_DEBUG_LEVEL > 0 -bool Tree::isValidAnyNode(AnyNodeRef const & node) { - OSL_ASSERT(nodeCount() != 0); - return node.isValid() && isValidNode(node.m_nUsedPos) && - (node.isNode() || - (view::ViewTreeAccess(this).isGroupNodeAt(node.m_nUsedPos) && - getMemberNode(node.toValue()).isValid())); -} -#endif - -bool Tree::hasElements(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth" ); - } - view::ViewTreeAccess v(this); - return v.isSetNode(node) && !v.isEmpty(v.toSetNode(node)); -} - -bool Tree::hasElement(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - return v.isSetNode(node) && - v.findElement(v.toSetNode(node), name).isValid(); -} - -bool Tree::hasElement(NodeRef const & node, Path::Component const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - if (v.isSetNode(node)) { - SetEntry e(v.findElement(v.toSetNode(node), name.getName())); - // Check if types match: - return e.isValid() && - Path::matches(e.tree()->getExtendedRootName(), name); - } else { - return false; - } -} - -rtl::Reference< ElementTree > Tree::getElement(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - if (v.isSetNode(node)) { - SetEntry e(v.findElement(v.toSetNode(node), name)); - return rtl::Reference< ElementTree >(e.tree()); - } else { - return rtl::Reference< ElementTree >(); - } -} - -rtl::Reference< ElementTree > Tree::getAvailableElement( - NodeRef const & node, rtl::OUString const & name) -{ - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - view::ViewTreeAccess v(this); - if (v.isSetNode(node)) { - SetEntry e(v.findAvailableElement(v.toSetNode(node), name)); - return rtl::Reference< ElementTree >(e.tree()); - } else { - return rtl::Reference< ElementTree >(); - } -} - -bool Tree::hasChildren(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - if (v.isGroupNode(node)) { - view::GroupNode g(v.toGroupNode(node)); - return v.hasValue(g) || g.getFirstChild().is(); - } else { - return false; - } -} - -bool Tree::hasChildValue(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - return v.isGroupNode(node) && v.hasValue(v.toGroupNode(node), name); -} - -bool Tree::hasChildNode(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - return v.isGroupNode(node) && v.toGroupNode(node).findChild(name).is(); -} - -bool Tree::hasChild(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - if (v.isGroupNode(node)) { - view::GroupNode g(v.toGroupNode(node)); - return v.hasValue(g, name) || g.findChild(name).is(); - } else { - return false; - } -} - -ValueRef Tree::getChildValue(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - return v.isGroupNode(node) && v.hasValue(v.toGroupNode(node), name) - ? ValueRef(name, node.getOffset()) : ValueRef(); -} - -NodeRef Tree::getChildNode(NodeRef const & node, rtl::OUString const & name) -{ - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - return NodeRef( - (v.isGroupNode(node) - ? v.toGroupNode(node).findChild(name).get_offset() : 0), - childDepth(node.getDepth())); -} - -AnyNodeRef Tree::getAnyChild(NodeRef const & node, rtl::OUString const & name) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - unsigned int n = 0; - if (v.isGroupNode(node)) { - if (v.hasValue(v.toGroupNode(node), name)) { - return AnyNodeRef(name, node.getOffset()); - } - n = v.toGroupNode(node).findChild(name).get_offset(); - } - return AnyNodeRef(n, childDepth(node.getDepth())); -} - -node::Attributes Tree::getAttributes(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - return view::ViewTreeAccess(this).getAttributes(node); -} - -node::Attributes Tree::getAttributes(AnyNodeRef const & node) { - OSL_ASSERT(nodeCount() != 0 && isValidAnyNode(node)); - if (node.isNode()) { - return view::ViewTreeAccess(this).getAttributes(node.toNode()); - } else { - return getMemberNode(node.toValue()).getAttributes(); - } -} - -node::Attributes Tree::getAttributes(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0 && isValidValueNode(value)); - return getMemberNode(value).getAttributes(); -} - -com::sun::star::uno::Type Tree::getUnoType(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0 && isValidValueNode(value)); - return getMemberNode(value).getValueType(); -} - -NodeRef Tree::getParent(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - view::ViewTreeAccess v(this); - OSL_ASSERT(!v.makeNode(getRootNode()).getParent().is()); - view::Node p(v.makeNode(node).getParent()); - OSL_ASSERT(isValidNode(p.get_offset())); - return NodeRef(p.get_offset(), parentDepth(node.getDepth())); -} - -NodeRef Tree::getParent(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0 && isValidValueNode(value)); - unsigned int n = value.m_nParentPos; - OSL_ASSERT(n == 0 || value.m_sNodeName.getLength() != 0); - return getNode(n); -} - -AbsolutePath Tree::getAbsolutePath(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - Path::Rep r; - prependLocalPathTo(node.getOffset(), r); - r.prepend(getRootPath().rep()); - return AbsolutePath(r); -} - -com::sun::star::uno::Any Tree::getNodeValue(ValueRef const & value) { - OSL_ASSERT(isValidValueNode(value)); - return getMemberNode(value).getValue(); -} - -bool Tree::hasNodeDefault(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0 && isValidValueNode(value)); - return getMemberNode(value).canGetDefaultValue(); -} - -bool Tree::isNodeDefault(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0 && isValidValueNode(value)); - return hasNodeDefault(value) && getMemberNode(value).isDefault(); -} - -bool Tree::hasNodeDefault(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - // Not a set, then it has no default: - return view::ViewTreeAccess(this).isSetNode(node); -} - -bool Tree::isNodeDefault(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (!hasNodeDefault(node)) { - return false; - } - view::ViewTreeAccess v(this); - OSL_ASSERT(v.isSetNode(node)); // not a set, then it has no default - // A set is default if all its elements are default: - return !FindNonDefaultElement::hasNonDefaultElement(v, v.toSetNode(node)); -} - -bool Tree::hasNodeDefault(AnyNodeRef const & node) { - OSL_ASSERT(nodeCount() != 0 && isValidAnyNode(node)); - return node.isNode() - ? hasNodeDefault(node.toNode()) : hasNodeDefault(node.toValue()); -} - -bool Tree::isNodeDefault(AnyNodeRef const & node) { - OSL_ASSERT(nodeCount() != 0 && isValidAnyNode(node)); - return node.isNode() - ? isNodeDefault(node.toNode()) : isNodeDefault(node.toValue()); -} - -bool Tree::areValueDefaultsAvailable(NodeRef const & node) { - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - view::ViewTreeAccess v(this); - OSL_ASSERT(v.isGroupNode(node)); - return v.isGroupNode(node) && - v.areValueDefaultsAvailable(v.toGroupNode(node)); -} - -com::sun::star::uno::Any Tree::getNodeDefaultValue(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0 && isValidValueNode(value)); - ValueMemberNode m(getMemberNode(value)); - return m.canGetDefaultValue() ? - m.getDefaultValue() : com::sun::star::uno::Any(); -} - -bool Tree::hasChanges() { - return view::ViewTreeAccess(this).hasChanges(); -} - -bool Tree::collectChanges(NodeChanges & changes) { - OSL_ASSERT(nodeCount() != 0); - view::ViewTreeAccess v(this); - if (v.hasChanges()) { - v.collectChanges(changes); - return true; - } else { - return false; - } -} - -void Tree::integrate(NodeChange & change, NodeRef const & node, bool local) -{ - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (change.test().isChange()) { - change.apply(); - if (local) { - view::ViewTreeAccess(this).markChanged(node); - } else { - rtl::Reference< Tree > at(change.getAffectedTree()); - NodeRef an(change.getAffectedNode()); - OSL_ASSERT( - !isEmpty(at.get()) && an.isValid() && - at->isValidNode(an.getOffset())); - view::ViewTreeAccess(at.get()).markChanged(an); - OSL_ASSERT(view::ViewTreeAccess(this).hasChanges()); - } - } -} - -void Tree::integrate(NodeChanges& changes, NodeRef const & node, bool local) -{ - for (std::vector< NodeChange >::iterator it(changes.begin()); - it != changes.end(); ++it) - { - integrate(*it, node, local); - } -} - -NodeVisitor::Result Tree::dispatchToChildren( - NodeRef const & node, NodeVisitor & visitor) -{ - OSL_ASSERT( - nodeCount() != 0 && node.isValid() && isValidNode(node.getOffset())); - if (node.getDepth() == 0) { - CFG_TRACE_WARNING( - "configuration: Querying node beyond available depth"); - } - view::ViewTreeAccess v(this); - if (v.isGroupNode(node)) { - view::GroupNode const p(v.toGroupNode(node)); - OSL_ASSERT( - (NodeVisitor::Result(GroupMemberVisitor::DONE) == - NodeVisitor::DONE) && - (NodeVisitor::Result(GroupMemberVisitor::CONTINUE) == - NodeVisitor::CONTINUE)); - GroupVisitorAdapter adapter(this, node, visitor); - NodeVisitor::Result ret = NodeVisitor::Result( - v.dispatchToValues(p, adapter)); - unsigned int n = childDepth(node.getDepth()); - for (view::Node c(p.getFirstChild()); - c.is() && ret != NodeVisitor::DONE; c = p.getNextChild(c)) - { - ret = visit(NodeRef(c.get_offset(), n), visitor); - } - return ret; - } else if (v.isSetNode(node)) { - OSL_ASSERT( - NodeVisitor::Result(SetNodeVisitor::DONE) == NodeVisitor::DONE && - (NodeVisitor::Result(SetNodeVisitor::CONTINUE) == - NodeVisitor::CONTINUE)); - SetVisitorAdapter adapter(visitor); - return NodeVisitor::Result( - v.dispatchToElements(v.toSetNode(node), adapter)); - } else { - OSL_TRACE("configuration: Trying to iterate a value node"); - return NodeVisitor::CONTINUE; - } -} - -NodeRef Tree::getNode(unsigned int offset) const { - if (offset == 0) { - return NodeRef(); - } else { - OSL_ASSERT(isValidNode(offset)); - return NodeRef( - offset, remainingDepth(getAvailableDepth(), depthTo(offset))); - } -} - -rtl::Reference< Template > Tree::extractElementInfo(NodeRef const & node) { - OSL_ASSERT(node.isValid() && isValidNode(node.getOffset())); - view::ViewTreeAccess v(this); - OSL_ASSERT(v.isSetNode(node)); - return v.getElementTemplate(v.toSetNode(node)); -} - -//----------------------------------------------------------------------------- -void Tree::rebuild(rtl::Reference<view::ViewStrategy> const & _xNewStrategy, sharable::Node * newData) -{ - m_xStrategy = _xNewStrategy; - this->implRebuild(ROOT, newData); -} - -//----------------------------------------------------------------------------- -void Tree::implRebuild(unsigned int nNode, sharable::Node * newData) -{ - NodeData * pNode = nodeData(nNode); - if (pNode->isGroupNode()) - { - // first rebuild the children - OSL_ASSERT(newData != 0 && newData->isGroup()); - sharable::GroupNode * newGroup = &newData->group; - - for (unsigned int nChild = firstChild_(nNode); isValidNode(nChild); nChild = findNextChild_(nNode,nChild)) - { - sharable::Node * childAccess = newGroup->getChild(implGetOriginalName(nChild)); - OSL_ASSERT(childAccess != 0); - implRebuild(nChild, childAccess); - } - } - - pNode->rebuild(m_xStrategy, newData); -} - -//----------------------------------------------------------------------------- - -void ElementTree::doFinishRootPath(Path::Rep& rPath) const -{ - rPath.prepend( doGetRootName() ); - rPath.prepend( AbsolutePath::detachedRoot().rep() ); -} -//----------------------------------------------------------------------------- - -void RootTree::doFinishRootPath(Path::Rep& rPath) const -{ - rPath.prepend( m_aRootPath.rep() ); -} - -//----------------------------------------------------------------------------- - -void Tree::implPrependRootPath(Path::Rep& rPath) const -{ - if (m_pParentTree) - { - rPath.prepend( doGetRootName() ); - OSL_ASSERT(m_nParentNode); - m_pParentTree->prependLocalPathTo(m_nParentNode,rPath); - m_pParentTree->implPrependRootPath(rPath); - } - else - { - doFinishRootPath( rPath ); - } -} -//----------------------------------------------------------------------------- - -AbsolutePath Tree::getRootPath() const -{ - Path::Rep aPath; - implPrependRootPath(aPath); - return AbsolutePath(aPath); -} -//----------------------------------------------------------------------------- -void Tree::build(rtl::Reference<view::ViewStrategy> const& _xStrategy, sharable::Node * rootNode, unsigned int nDepth, TemplateProvider const& aTemplateProvider) -{ - OSL_ASSERT(m_aNodes.empty()); - m_nDepth = nDepth; - TreeImplBuilder a(aTemplateProvider, _xStrategy,*this); - a.visitNode(rootNode); -} -//----------------------------------------------------------------------------- - -rtl::Reference< view::ViewStrategy > Tree::getViewBehavior() const -{ - return m_xStrategy; -} - -// context handling -//----------------------------------------------------------------------------- - -void Tree::setContext(Tree* pParentTree, unsigned int nParentNode) -{ - OSL_ENSURE(pParentTree,"ERROR: Moving tree to nowhere"); - - if (pParentTree) - { - OSL_ENSURE( pParentTree->isValidNode(nParentNode),"ERROR: Moving tree to invalid node"); - if (!pParentTree->isValidNode(nParentNode)) - throw Exception("INTERNAL ERROR: Moving tree to invalid parent node"); - - // OSL_ENSURE( pParentTree->isSetNodeAt(nParentNode),"WARNING: Moving tree to node that is not a set"); - } - else - { - OSL_ENSURE( nParentNode == 0,"WARNING: Moving tree to node without a tree"); - nParentNode = 0; - } - - m_pParentTree = pParentTree; - m_nParentNode = nParentNode; -} -//----------------------------------------------------------------------------- - -void Tree::clearContext() -{ - m_pParentTree = 0; - m_nParentNode = 0; -} -//----------------------------------------------------------------------------- - -//----------------------------------------------------------------------------- -// Node Collection navigation -//----------------------------------------------------------------------------- - -unsigned int Tree::parent_(unsigned int nNode) const -{ - OSL_ASSERT(isValidNode(nNode)); - return nodeData(nNode)->getParent(); -} -//----------------------------------------------------------------------------- -inline // is protected and should be used only here -rtl::OUString Tree::implGetOriginalName(unsigned int nNode) const -{ - OSL_ASSERT(isValidNode(nNode)); - - return nodeData(nNode)->getName(); -} -//----------------------------------------------------------------------------- - -Path::Component ElementTree::doGetRootName() const -{ - return makeExtendedName( m_aElementName ); -} - -//----------------------------------------------------------------------------- - -rtl::OUString ElementTree::getSimpleRootName() const -{ - // Tree::getSimpleRootName tends to parse & - // then split the same name, burning CPU L&R - return m_aElementName; -} - -//----------------------------------------------------------------------------- - -Path::Component RootTree::doGetRootName() const -{ - return m_aRootPath.getLocalName(); -} -//----------------------------------------------------------------------------- - - -rtl::OUString Tree::getSimpleNodeName(unsigned int nNode) const -{ - if (nNode == ROOT) return getSimpleRootName(); - - return implGetOriginalName(nNode); -} -//----------------------------------------------------------------------------- - -rtl::OUString Tree::getSimpleRootName() const -{ - return doGetRootName().getName(); -} - -//----------------------------------------------------------------------------- - -Path::Component Tree::getExtendedRootName() const -{ - return doGetRootName(); -} -//----------------------------------------------------------------------------- - -unsigned int Tree::depthTo(unsigned int nNode) const -{ - OSL_ASSERT(isValidNode(nNode)); - - unsigned int nDepth = 0; - while( 0 != (nNode=parent_(nNode)) ) - { - ++nDepth; - } - - return nDepth; -} -//----------------------------------------------------------------------------- - -void Tree::prependLocalPathTo(unsigned int nNode, Path::Rep& rNames) -{ - OSL_ASSERT(isValidNode(nNode)); - - for (; nNode != ROOT; nNode = parent_(nNode) ) - { - OSL_ENSURE( isValidNode(nNode), "ERROR: Configuration: node has invalid parent"); - rNames.prepend( Path::wrapSimpleName( implGetOriginalName(nNode) ) ); - } - - OSL_ASSERT(nNode == ROOT); -} -//----------------------------------------------------------------------------- - -// Node iteration and access -unsigned int Tree::firstChild_ (unsigned int nParent) const -{ - return findNextChild_(nParent,nParent); -} -//----------------------------------------------------------------------------- - -unsigned int Tree::findNextChild_(unsigned int nParent, unsigned int nStartAfter) const -{ - OSL_ASSERT(isValidNode(nParent)); - OSL_ASSERT(nStartAfter == 0 || isValidNode(nStartAfter)); - - unsigned int nPos = nStartAfter ? nStartAfter : ROOT - 1; - unsigned int const nAfterLast = nodeCount() + ROOT; - while (++nPos < nAfterLast) - { - if(parent_(nPos) == nParent) return nPos; - } - return 0; -} -//----------------------------------------------------------------------------- - -unsigned int Tree::findChild_(unsigned int nParent, rtl::OUString const& aName) const -{ - OSL_ASSERT(isValidNode(nParent)); - - unsigned int nPos = nParent; - unsigned int const nAfterLast = nodeCount() + ROOT; - while (++nPos < nAfterLast) - { - if(parent_(nPos) == nParent && implGetOriginalName(nPos) == aName) - return nPos; - } - return 0; -} - -ValueMemberNode Tree::getMemberNode(ValueRef const & value) { - OSL_ASSERT(nodeCount() != 0); - view::ViewTreeAccess v(this); - return v.getValue(v.getGroupNodeAt(value.m_nParentPos), value.m_sNodeName); -} - -//----------------------------------------------------------------------------- -// class RootTree -//----------------------------------------------------------------------------- - -RootTree::RootTree( rtl::Reference<view::ViewStrategy> const& _xStrategy, - AbsolutePath const& aRootPath, - sharable::Node * cacheNode, unsigned int nDepth, - TemplateProvider const& aTemplateProvider) -: Tree() -, m_aRootPath(aRootPath) -{ -// OSL_ENSURE( aRootPath.getLocalName().getName() == cacheNode->getName(), -// "Constructing root node: Path does not match node name"); - - Tree::build(_xStrategy,cacheNode,nDepth,aTemplateProvider); -} - -bool isEmpty(Tree * tree) -{ - return tree == 0 || tree->nodeCount() == 0; -} - -//----------------------------------------------------------------------------- -// class ElementTree -//----------------------------------------------------------------------------- - -ElementTree::ElementTree( rtl::Reference<view::ViewStrategy> const& _xStrategy, - sharable::TreeFragment * cacheTree, unsigned int nDepth, - rtl::Reference<Template> aTemplateInfo, - TemplateProvider const& aTemplateProvider ) -: Tree() -, m_aInstanceInfo(aTemplateInfo) -, m_aElementName(cacheTree->getName()) -, m_aDataAddress(cacheTree) -, m_aOwnData() -{ - Tree::build( _xStrategy, cacheTree->getRootNode(), nDepth, aTemplateProvider ); -} -//----------------------------------------------------------------------------- - -ElementTree::ElementTree( rtl::Reference<view::ViewStrategy> const& _xStrategy, - Tree& rParentTree, unsigned int nParentNode, - sharable::TreeFragment * cacheTree, unsigned int nDepth, - rtl::Reference<Template> aTemplateInfo, - TemplateProvider const& aTemplateProvider ) -: Tree( rParentTree, nParentNode ) -, m_aInstanceInfo(aTemplateInfo) -, m_aElementName(cacheTree->getName()) -, m_aDataAddress(cacheTree) -, m_aOwnData() -{ - Tree::build( _xStrategy, cacheTree->getRootNode(), nDepth, aTemplateProvider ); -} -//----------------------------------------------------------------------------- - -ElementTree::ElementTree( rtl::Reference< data::TreeSegment > const& pNewTree, - rtl::Reference<Template> aTemplate, - TemplateProvider const& aTemplateProvider ) -: Tree() -, m_aInstanceInfo(aTemplate) -, m_aOwnData(pNewTree) -{ - if (!pNewTree.is()) - throw Exception("ERROR: Provider can't create Element Instance From Template"); - m_aElementName = pNewTree->fragment->getName(); - m_aDataAddress = pNewTree->fragment; - - Tree::build( view::createDirectAccessStrategy(m_aOwnData), m_aOwnData->fragment->nodes, c_TreeDepthAll, aTemplateProvider ); -} -//----------------------------------------------------------------------------- - -ElementTree::~ElementTree() -{ -} -//----------------------------------------------------------------------------- - -bool ElementTree::isUpdatableSegment(Tree& _rTree) -{ - Tree * pTree = &_rTree; - - while (ElementTree * pElement = dynamic_cast< ElementTree * >(pTree)) - { - if (pElement->m_aOwnData.is()) - { - OSL_ENSURE( pElement->getContextTree()==NULL || - pElement->getContextTree()->getViewBehavior() != pElement->getViewBehavior(), - "ElementTree with parent in same fragment should not own its data"); - return true; - } - - pTree = pElement->getContextTree(); - - if (!pTree) - { - OSL_ENSURE( false, "ElementTree without own data should have a parent"); - return false; - } - - } - OSL_ENSURE( false, "Tree is not part of free-floating segment - cannot support direct update"); - - return false; -} -//----------------------------------------------------------------------------- - -void ElementTree::disposeData() -{ - Tree::disposeData(); - m_aOwnData.clear(); -} -//----------------------------------------------------------------------------- - -Path::Component ElementTree::makeExtendedName(rtl::OUString const& _aSimpleName) const -{ - rtl::OUString aTypeName = implGetOriginalName(ROOT); - - OSL_ENSURE(this->isTemplateInstance(), "ElementTree: Cannot discover the type this instantiatiates"); - - OSL_ENSURE(! this->isTemplateInstance() || this->getTemplate()->getName() == aTypeName, - "ElementTree: Type name does not match template"); - - return Path::makeCompositeName(_aSimpleName, aTypeName); -} -//----------------------------------------------------------------------------- - -// ownership handling -//----------------------------------------------------------------------------- -void ElementTree::rebuild(rtl::Reference<view::ViewStrategy> const & _aStrategy, sharable::TreeFragment * newTree) -{ - Tree::rebuild(_aStrategy, newTree->getRootNode()); - m_aDataAddress = newTree; - m_aElementName = newTree->getName(); -} - -//----------------------------------------------------------------------------- -/// transfer ownership to the given set -// ----------------------------------------------------------------------------- -void ElementTree::attachTo(sharable::SetNode * owningSet, rtl::OUString const& aElementName) -{ - OSL_ENSURE(m_aOwnData.is(), "ERROR: Cannot add a non-owned node to a subtree"); - - if (m_aOwnData.is()) - { - OSL_ENSURE(this->getSimpleRootName() == aElementName,"ElementTree: Attaching with unexpected element name"); - m_aOwnData->fragment->setName(aElementName); - - Tree* pOwningTree = this->getContextTree(); - OSL_ENSURE(pOwningTree, "Element Tree Context must be set before attaching data"); - - if (isUpdatableSegment(*pOwningTree)) - { - // copy over to the new segment - sharable::TreeFragment * aNewElement = data::buildTree(m_aOwnData->fragment); - - owningSet->addElement(aNewElement); - - rtl::Reference<view::ViewStrategy> xNewBehavior = pOwningTree->getViewBehavior(); - - this->rebuild(xNewBehavior,aNewElement); - } - else - OSL_ENSURE( false, "Cannot attach directly to new tree - no update access available"); - - m_aOwnData.clear(); - OSL_ASSERT(!m_aOwnData.is()); - } -} -//----------------------------------------------------------------------------- - -/// tranfer ownership from the given set -void ElementTree::detachFrom(sharable::SetNode * owningSet, rtl::OUString const& aElementName) -{ - OSL_ENSURE(!m_aOwnData.is(),"ERROR: Cannot detach a already owned node from a subtree"); - OSL_ENSURE(this->getSimpleRootName() == aElementName,"ElementTree: Detaching with unexpected element name"); - - rtl::Reference< view::ViewStrategy > xOldStrategy = this->getViewBehavior(); - OSL_ENSURE(xOldStrategy.is(), "Element Tree Context must still have the old strategy when detaching data"); - - { - // make a new segment with a copy of the data - rtl::Reference< data::TreeSegment > aNewSegment = data::TreeSegment::create( this->getOriginalTreeAccess() ); - - OSL_ENSURE(aNewSegment.is(),"ERROR: Could not create detached copy of elment data"); - - this->takeTreeAndRebuild( aNewSegment ); - - sharable::TreeFragment * aOldElement = owningSet->removeElement(aElementName ); - OSL_ENSURE(aOldElement != NULL,"ERROR: Detached node not found in the given subtree"); - - data::destroyTree(aOldElement); - } - - OSL_ENSURE(m_aOwnData.is(),"ERROR: Could not create own data segment for detached node"); -} -//----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- - -/// transfer ownership from the given owner -void ElementTree::takeTreeBack(rtl::Reference< data::TreeSegment > const & _aDataSegment) -{ - OSL_ENSURE(!m_aOwnData.is(), "ERROR: Cannot take over a node - already owning"); - OSL_ENSURE(_aDataSegment.is(), "ERROR: Cannot take over NULL tree segment"); - - m_aOwnData = _aDataSegment; - OSL_ENSURE(m_aOwnData.is(), "ERROR: Could not take over data segment"); - - m_aDataAddress = m_aOwnData->fragment; - m_aElementName = m_aOwnData->fragment->getName(); -} -//----------------------------------------------------------------------------- - -/// transfer ownership from the given owner -void ElementTree::takeTreeAndRebuild(rtl::Reference< data::TreeSegment > const & _aDataSegment) -{ - OSL_ENSURE(!m_aOwnData.is(), "ERROR: Cannot take over a node - already owning"); - OSL_ENSURE(_aDataSegment.is(), "ERROR: Cannot take over NULL tree segment"); - this->rebuild(view::createDirectAccessStrategy(_aDataSegment), _aDataSegment->fragment); - m_aOwnData = _aDataSegment; -} -//----------------------------------------------------------------------------- - -/// release ownership -rtl::Reference< data::TreeSegment > ElementTree::releaseOwnedTree() -{ - OSL_ENSURE(m_aOwnData.is(), "ERROR: Cannot release and rename a non-owned node"); - rtl::Reference< data::TreeSegment > aTree(m_aOwnData); - m_aOwnData.clear(); - aTree->fragment->setName(m_aElementName); - return aTree; -} -//----------------------------------------------------------------------------- - -// context handling -//----------------------------------------------------------------------------- - -/// renames the tree's root without concern for context consistency ! -void ElementTree::renameTree(rtl::OUString const& aNewName) -{ - m_aElementName = aNewName; -} -//----------------------------------------------------------------------------- - -void ElementTree::moveTree(Tree* pParentTree, unsigned int nParentNode) -{ - Tree::setContext(pParentTree,nParentNode); -} -//----------------------------------------------------------------------------- - -void ElementTree::detachTree() -{ - Tree::clearContext(); -} -//----------------------------------------------------------------------------- - -//----------------------------------------------------------------------------- - } // namespace configuration -} // namespace configmgr - |