diff options
Diffstat (limited to 'configmgr/source/inc/tree.hxx')
| -rw-r--r-- | configmgr/source/inc/tree.hxx | 665 |
1 files changed, 0 insertions, 665 deletions
diff --git a/configmgr/source/inc/tree.hxx b/configmgr/source/inc/tree.hxx deleted file mode 100644 index a8661173c068..000000000000 --- a/configmgr/source/inc/tree.hxx +++ /dev/null @@ -1,665 +0,0 @@ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * 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. - * - ************************************************************************/ - -#ifndef CONFIGMGR_CONFIGNODEIMPL_HXX_ -#define CONFIGMGR_CONFIGNODEIMPL_HXX_ - -#include "change.hxx" -#include "configpath.hxx" -#include "template.hxx" -#include "utility.hxx" -#include <rtl/ref.hxx> -#include <salhelper/simplereferenceobject.hxx> -#include <osl/diagnose.h> - -#ifndef INCLUDED_VECTOR -#include <vector> -#define INCLUDED_VECTOR -#endif -#ifndef INCLUDED_MAP -#include <map> -#define INCLUDED_MAP -#endif -#ifndef INCLUDED_MEMORY -#include <memory> -#define INCLUDED_MEMORY -#endif - -namespace configmgr -{ - namespace node { struct Attributes; } - namespace sharable { union Node; } - namespace view { class ViewStrategy; } - namespace configuration - { -//----------------------------------------------------------------------------- - class AnyNodeRef; - class ElementTree; - class GroupNodeImpl; - class NodeChange; - class NodeChanges; - class NodeImpl; - class NodeRef; - class SetNodeImpl; - class TemplateProvider; - class Tree; - class ValueElementNodeImpl; - class ValueMemberNode; - class ValueRef; -//----------------------------------------------------------------------------- - // WARNING: a similar item is in noderef.hxx - const unsigned int c_TreeDepthAll = ~0u; - -//----------------------------------------------------------------------------- - inline - unsigned int& incDepth(unsigned int& rDepth) - { - if (rDepth != c_TreeDepthAll) ++rDepth; - return rDepth; - } - - inline - unsigned int& decDepth(unsigned int& rDepth) - { - OSL_ENSURE(rDepth != 0,"Cannot decrement zero depth"); - if (rDepth != c_TreeDepthAll && rDepth != 0) --rDepth; - return rDepth; - } - - inline - unsigned int childDepth(unsigned int nDepth) - { return decDepth(nDepth); } - - inline - unsigned int parentDepth(unsigned int nDepth) - { return incDepth(nDepth); } - - inline - unsigned int remainingDepth(unsigned int nOuterDepth, unsigned int nRelativeDepth) - { - OSL_ENSURE(nRelativeDepth != c_TreeDepthAll,"RelativeDepth can't be infinite"); - OSL_ENSURE(nRelativeDepth <= nOuterDepth,"ERROR: RelativeDepth is larger than enclosing depth"); - - unsigned int nInnerDepth = (nOuterDepth == c_TreeDepthAll) ? nOuterDepth : - (nRelativeDepth < nOuterDepth) ? nOuterDepth-nRelativeDepth : - 0; - return nInnerDepth; - } - //------------------------------------------------------------------------- - - /// interface for a class that can be used to do some operation on a set of <type>NodeRef</type>s and <type>ValueRef</type>s. - struct NodeVisitor - { - /// returned from <method>handle</method> to indicate whether the operation is complete or should continue - enum Result { DONE, CONTINUE }; - /// do the operation on <var>aNode</var>. needs to be implemented by concrete visitor classes - virtual Result handle(rtl::Reference< Tree > const& aTree, NodeRef const& aNode) = 0; - /// do the operation on <var>aValue</var>. needs to be implemented by concrete visitor classes - virtual Result handle(rtl::Reference< Tree > const& aTree, ValueRef const& aValue) = 0; - protected: - virtual ~NodeVisitor() {} - }; -//----------------------------------------------------------------------------- - -// class Node Impl -//----------------------------------------------------------------------------- - - /** is the Implementation class for class <type>Node</type>, held inside a <type>Tree</type>. - <p> Implements some functionality common to all node types. - </p> - <p> Otherwise it provides (not really typesafe) access to a - <type scope='configmgr::configuration::NodeType>NodeImpl</type> which implements - functionality for a node of a given type - (as given by a <type scope='configmgr::configuration::NodeType>Enum</type> value). - </p> - */ - class NodeData - { - rtl::Reference<NodeImpl> m_pSpecificNode; - rtl::OUString m_aName_; // cached for better performance - unsigned int m_nParent; - public: - NodeData(rtl::Reference<NodeImpl> const& aSpecificNodeImpl, rtl::OUString const& aName, unsigned int nParent); - - void rebuild(rtl::Reference<view::ViewStrategy> const& _xNewStrategy, sharable::Node * _aNewData); - // COMMON: information - rtl::OUString getName() const { return m_aName_; } - unsigned int getParent() const { return m_nParent; } - - // change management - public: - // BASIC NODE: access to common attributes - NodeImpl & nodeImpl() { return implGetNodeImpl(); } - NodeImpl const & nodeImpl() const { return implGetNodeImpl(); } - - // SET: access to child elements - bool isSetNode() const; - SetNodeImpl& setImpl() { return implGetSetImpl(); } - SetNodeImpl const& setImpl() const { return implGetSetImpl(); } - - // VALUES: access to data - bool isValueElementNode() const; - ValueElementNodeImpl& valueElementImpl() { return implGetValueImpl(); } - ValueElementNodeImpl const& valueElementImpl() const { return implGetValueImpl(); } - - // GROUP: access to children - bool isGroupNode() const; - GroupNodeImpl& groupImpl() { return implGetGroupImpl(); } - GroupNodeImpl const&groupImpl() const { return implGetGroupImpl(); } - - // access helper - public: - sharable::Node * getOriginalNodeAccess() const; - - private: - NodeImpl& implGetNodeImpl() const; - SetNodeImpl& implGetSetImpl() const; - GroupNodeImpl& implGetGroupImpl() const ; - ValueElementNodeImpl& implGetValueImpl() const ; - }; -//----------------------------------------------------------------------------- - /** represents a hierarchy of config entries (identified by <type>NodeRef</type>s and <type>ValueRef</type>s) - - <p>Examples for trees include</p> - <ulist> - <li>A module tree (for a specific set of parameters).</li> - <li>An updating tree (for a part of the whole).</li> - <li>A set element (updating or not), which could be detached.</li> - <ulist> - <p> Holds a list of <type>Node</type> which it allows to access by - <type>unsigned int</type> (which is basically a one-based index). - </p> - <p> Also provides for navigation to the context this tree is located in - </p> - */ - class Tree : public salhelper::SimpleReferenceObject - { - friend class view::ViewStrategy; - protected: - // Construction - /// creates a Tree for a detached, virgin tree - Tree( ); - - /// creates a Tree with a parent tree - Tree(Tree& rParentTree, unsigned int nParentNode); - - virtual ~Tree() = 0; - - /// fills this Tree starting from _aRootNode, using the given factory and the tree's template provider - void build(rtl::Reference<view::ViewStrategy> const& _xStrategy, sharable::Node * _aRootNode, unsigned int nDepth, TemplateProvider const& aTemplateProvider); - - void rebuild(rtl::Reference<view::ViewStrategy> const& _xNewStrategy, sharable::Node * _aNewData); - - public: - // realeses the data this refers to - virtual void disposeData(); - - // Context Access - /// gets the path to the root node of this tree - AbsolutePath getRootPath() const; - /// gets the tree of parent node of this tree - Tree* getContextTree() { return m_pParentTree; } - /// gets the tree of parent node of this tree - Tree const *getContextTree() const { return m_pParentTree; } - /// gets the offset of parent node of this tree within its tree - unsigned int getContextNode() const { return m_nParentNode; } - - // Node Collection information - /// checks whether <var>nNode</var> is a valid node offset in this tree - bool isValidNode(unsigned int nNode) const; - - bool isRootNode(NodeRef const & node) const; - - NodeRef getRootNode() const; - - NodeRef getContextNodeRef() const; - - bool isValidValueNode(ValueRef const & value); - -#if OSL_DEBUG_LEVEL > 0 - bool isValidAnyNode(AnyNodeRef const & node); -#endif - - /// checks whether the node has any element nodes (of its own) - bool hasElements(NodeRef const & node); - - bool hasElement(NodeRef const & node, rtl::OUString const & name); - - bool hasElement(NodeRef const & node, Path::Component const & name); - - /** gets the element with the given name of the given node - <p>PRE: <code>hasElement(node, name)</code></p> - <p>If there is no such element, may return an empty node or - raise an exception (?)</p> - - @throws InvalidName - if name is not a valid child name for this node - */ - rtl::Reference< ElementTree > getElement( - NodeRef const & node, rtl::OUString const & name); - - /** gets the element with the given name of the given node, if it is - available - <p>PRE: <code>hasElement(node, name)</code></p> - <p>If there is no such element, may return an empty node or - raise an exception (?)</p> - <p>Caution: May miss existing children unless hasChild/getChild - has been called before.</p> - - @throws InvalidName - if name is not a valid child name for this node - */ - rtl::Reference< ElementTree > getAvailableElement( - NodeRef const & node, rtl::OUString const & name); - - /// checks whether the node has any child nodes (in this tree) - bool hasChildren(NodeRef const & node); - - bool hasChildValue( - NodeRef const & node, rtl::OUString const & name); - - bool hasChildNode(NodeRef const & node, rtl::OUString const & name); - - bool hasChild(NodeRef const & node, rtl::OUString const & name); - - /** gets the child value (in this tree) with the given name of the - given node - <p>PRE: <code>hasChildValue(node, name)</code></p> - <P>If there is no such node, may return an empty node or raise - an exception (?)</p> - - @throws InvalidName - if <var>aName</var> is not a valid child name for this node - */ - ValueRef getChildValue( - NodeRef const & node, rtl::OUString const & name); - - NodeRef getChildNode( - NodeRef const & node, rtl::OUString const & name); - - AnyNodeRef getAnyChild( - NodeRef const& node, rtl::OUString const & name); - - node::Attributes getAttributes(NodeRef const & node); - - node::Attributes getAttributes(AnyNodeRef const & node); - - node::Attributes getAttributes(ValueRef const & value); - - com::sun::star::uno::Type getUnoType(ValueRef const & value); - - /// return the parent of the given node (or an empty node, if it is - /// the tree root) - NodeRef getParent(NodeRef const & node); - - /// return the parent of the given value (or an empty node, if it is - /// the tree root) - NodeRef getParent(ValueRef const & value); - - AbsolutePath getAbsolutePath(NodeRef const & node); - - /// retrieves the current value for the given node, provided there - /// is one and it is available (only works for value nodes) - com::sun::star::uno::Any getNodeValue(ValueRef const & value); - - /// checks whether the given node has a default value (only works - /// for value nodes) - bool hasNodeDefault(ValueRef const & value); - - /// checks whether the given node assumes its default value (only - /// works for value nodes) - bool isNodeDefault(ValueRef const & value); - - /// checks whether the given node has a default state - bool hasNodeDefault(NodeRef const & node); - - /// checks whether the given node assumes its default state - bool isNodeDefault(NodeRef const & node); - - /// checks whether the given node has a default state - bool hasNodeDefault(AnyNodeRef const & node); - - /// checks whether the given node assumes its default state - bool isNodeDefault(AnyNodeRef const & node); - - /// checks whether the default values are available for the children - /// of the given node (if applicable) - bool areValueDefaultsAvailable(NodeRef const & node); - - /// retrieves the default value for the given node, provided there - /// is one and it is available (only works for value nodes) - com::sun::star::uno::Any getNodeDefaultValue( - ValueRef const & value); - - bool hasChanges(); - - /// lists any pending changes on this tree - bool collectChanges(NodeChanges & changes); - - void integrate( - NodeChange & change, NodeRef const & node, bool local); - - void integrate( - NodeChanges & changes, NodeRef const & node, bool local); - - NodeVisitor::Result visit( - NodeRef const & node, NodeVisitor & visitor) - { return visitor.handle(this, node); } - - NodeVisitor::Result visit( - ValueRef const & value, NodeVisitor & visitor) - { return visitor.handle(this, value); } - - /** lets the given visitor visit the child nodes of the given node - - The order in which nodes are visited is repeatable (but - currently unspecified). Visits nodes until NodeVisitor::DONE is - returned, then returns NodeVisitor::DONE. If all visits return - NodeVisitor::CONTINUE, returns NodeVisitor::CONTINUE. If no - children are present, returns NodeVisitor::CONTINUE. - */ - NodeVisitor::Result dispatchToChildren( - NodeRef const & node, NodeVisitor & visitor); - - NodeRef getNode(unsigned int offset) const; - - rtl::Reference< Template > extractElementInfo(NodeRef const & node); - - /// gets the depth that is available in this tree (due to the original request) - unsigned int getAvailableDepth() const { return m_nDepth; } - - /// gets the depth that is available in this tree within the given node - unsigned int getRemainingDepth(unsigned int nNode) const - { return remainingDepth(getAvailableDepth(),depthTo(nNode)); } - - // Node Collection navigation - /** gets the simple name of the node <var>nNode</var> - <p>PRE: <code>isValidNode(nNode)</code> - </p> - */ - rtl::OUString getSimpleNodeName(unsigned int nNode) const; - - /** gets the simple name of the root node (i.e. of the tree as a whole) - */ - virtual rtl::OUString getSimpleRootName() const; - - /** gets the full name of the root node - */ - Path::Component getExtendedRootName() const; - - /** gets the number of hierarchy levels from the root node to node <var>nNode</var> - in this tree - <p>In particular <code>depthTo(N) == 0</code> if <code>N == root()</code> - </p> - <p>PRE: <code>isValidNode(nNode)</code> - </p> - */ - unsigned int depthTo(unsigned int nNode) const; - - /// append the local path (relative to root) to a node to a collection of names - void prependLocalPathTo(unsigned int nNode, Path::Rep& rNames); - - // check whether defaults are available - bool hasDefaults(unsigned int _nNode) const; - public: - enum { ROOT = 1 }; /// base of <type>unsigned int</type>s used in this class - - /** gets the <type>unsigned int</type> of the parent node <var>nNode</var> in this tree - or 0 (zero) if it is the root node - <p>PRE: <code>isValidNode(nNode)</code> - </p> - */ - unsigned int parent_(unsigned int nNode) const; - - // Node iteration and access - /** gets the <type>unsigned int</type> of the first child node - of node <var>nParent</var> in this tree (in list order) - or 0 (zero) if it has no children in this tree - <p>PRE: <code>isValidNode(nParent)</code> - </p> - */ - unsigned int firstChild_ (unsigned int nParent) const; - - /** gets the <type>unsigned int</type> of the first child node - of node <var>nParent</var> that is after - node <var>nNode</var> in this tree (in list order) - or 0 (zero) if there is no such node - <p>if <code>nStartAfter == 0</code> searching starts at the beginning - </p> - <p>PRE: <code>isValidNode(nParent)</code> - </p> - <p>PRE: <code>isValidNode(nStartAfter) || nStartAfter == 0</code> - </p> - */ - unsigned int findNextChild_(unsigned int nParent, unsigned int nStartAfter) const; - - /** gets the <type>unsigned int</type> of the first (and only) child node - of node <var>nParent</var> in this tree (in list order) - where the name of the node is <var>aName</var>, - or 0 (zero) if there is no such node - <p>PRE: <code>isValidNode(nParent)</code> - </p> - */ - unsigned int findChild_(unsigned int nParent, rtl::OUString const& aName) const; - - // Node Collection access - /// get the number of nodes in this tree - unsigned int nodeCount() const; - - /// get the <type>NodeData</type> for node <var>nNode</var> in this tree - NodeData* nodeData(unsigned int nNode); - /// get the <type>NodeData</type> for node <var>nNode</var> in this tree - NodeData const* nodeData(unsigned int nNode) const; - /// get the <type>NodeData</type> for node <var>nNode</var> in this tree - NodeImpl& nodeImpl(unsigned int nNode) { return nodeData(nNode)->nodeImpl(); } - /// get the <type>NodeData</type> for node <var>nNode</var> in this tree - NodeImpl const& nodeImpl(unsigned int nNode) const { return nodeData(nNode)->nodeImpl(); } - - unsigned int nodeOffset(NodeData const & rNodeData) const; - - // Behavior - rtl::Reference< view::ViewStrategy > getViewBehavior() const; - protected: - // immediate commit -/* // implementation of commit protocol - void commitDirect(); - - void implCommitDirectFrom(unsigned int nNode); -*/ - void implRebuild(unsigned int nNode, sharable::Node * _aNewData); - - protected: - /// set a new parent context for this tree - void setContext(Tree* pParentTree, unsigned int nParentNode); - /// set no-parent context for this tree - void clearContext(); - - inline // is protected and should be used only in the implementation - rtl::OUString implGetOriginalName(unsigned int nNode) const; - - private: - /// get the full name of the root of this tree - virtual Path::Component doGetRootName() const = 0; - - /// prepend the absolute path to the root of this tree (no context use) - virtual void doFinishRootPath(Path::Rep& rPath) const = 0; - - ValueMemberNode getMemberNode(ValueRef const & value); - - rtl::Reference<view::ViewStrategy> m_xStrategy; - std::vector<NodeData> m_aNodes; - Tree* m_pParentTree; - unsigned int m_nParentNode; - unsigned int m_nDepth; - - /// prepend the absolute path to the root of this tree (using context if present) - void implPrependRootPath(Path::Rep& rPath) const; - - friend class TreeImplBuilder; - }; - - /// checks, if tree represents a real tree - bool isEmpty(Tree * tree); -//----------------------------------------------------------------------------- - - class ElementTree : public Tree - { - public: - - /// creates a Tree for a detached, virgin instance of <var>aTemplate</var> (always will be direct) - ElementTree(rtl::Reference< data::TreeSegment > const& _aElementData, rtl::Reference<Template> aTemplate, TemplateProvider const& aTemplateProvider ); - - /** creates a Tree with a parent tree, that (supposedly) - is an instance of <var>aTemplateInfo</var> - */ - ElementTree(rtl::Reference<view::ViewStrategy> const& _xStrategy, - Tree& rParentTree, unsigned int nParentNode, - sharable::TreeFragment * dataTree, unsigned int nDepth, - rtl::Reference<Template> aTemplateInfo, - TemplateProvider const& aTemplateProvider ); - - /** creates a Tree with no parent node, that (supposedly) - is an instance of <var>aTemplateInfo</var> - */ - ElementTree(rtl::Reference<view::ViewStrategy> const& _xStrategy, - sharable::TreeFragment * dataTree, unsigned int nDepth, - rtl::Reference<Template> aTemplateInfo, - TemplateProvider const& aTemplateProvider ); - - ~ElementTree(); - - // realeses the data this refers to - virtual void disposeData(); - - // rebuilding - using Tree::rebuild; - void rebuild(rtl::Reference<view::ViewStrategy> const& _xNewStrategy, sharable::TreeFragment * newData); - - // data access - sharable::TreeFragment * getOriginalTreeAccess() const { return m_aDataAddress; } - - // Tree information - virtual rtl::OUString getSimpleRootName() const; - /// checks whether this is an instance of a known template - bool isTemplateInstance() const { return !!m_aInstanceInfo.is(); } - /// checks whether this is an instance of the given template - bool isInstanceOf(rtl::Reference<Template> const& aTemplateInfo) const - { return m_aInstanceInfo == aTemplateInfo && aTemplateInfo.is(); } - /// retrieves the template that this is an instance of - rtl::Reference<Template> getTemplate() const { return m_aInstanceInfo; } - /// makes a complete name from a simple name and template information - Path::Component makeExtendedName(rtl::OUString const& aSimpleName) const; - - // node control operation - /// check if this is a free-floating tree - bool isFree() const { return m_aOwnData.is(); } - /// transfer ownership to the given set - void attachTo(sharable::SetNode * updatableSetNode, rtl::OUString const& aElementName); - /// tranfer ownership from the given set - void detachFrom(sharable::SetNode * updatableSetNode, rtl::OUString const& aElementName); - - /// take ownership of the given tree (which must not already be the one in use) - void takeTreeAndRebuild(rtl::Reference< data::TreeSegment > const& _aElementData); - /// take ownership of the given tree (which must already be the one in use) - void takeTreeBack(rtl::Reference< data::TreeSegment > const& _aElementData); - - /// release ownership - rtl::Reference< data::TreeSegment > releaseOwnedTree(); - - // context operation - /// set a new root name - void renameTree(rtl::OUString const& aNewName); - /// set a new parent context for this tree - void moveTree(Tree* pParentTree, unsigned int nParentNode); - /// set no-parent context for this tree - void detachTree(); - - private: - static bool isUpdatableSegment(Tree& _rTree); - - virtual Path::Component doGetRootName() const; - - virtual void doFinishRootPath(Path::Rep& rPath) const; - private: - rtl::Reference<Template> const m_aInstanceInfo; - rtl::OUString m_aElementName; - sharable::TreeFragment * m_aDataAddress; - rtl::Reference< data::TreeSegment > m_aOwnData; - }; -//----------------------------------------------------------------------------- - inline - bool Tree::isValidNode(unsigned int nNode) const - { - return ROOT <= nNode && nNode < nodeCount() + ROOT; - } - //--------------------------------------------------------------------- - inline - unsigned int Tree::nodeCount() const - { - return m_aNodes.size(); - } - //--------------------------------------------------------------------- - inline - NodeData* Tree::nodeData(unsigned int nNode) - { - if (nNode == 0) return NULL; - OSL_ASSERT(isValidNode(nNode)); - return &m_aNodes[nNode - ROOT]; - } - //--------------------------------------------------------------------- - inline - NodeData const* Tree::nodeData(unsigned int nNode) const - { - if (nNode == 0) return NULL; - OSL_ASSERT(isValidNode(nNode)); - return &m_aNodes[nNode - ROOT]; - } - //--------------------------------------------------------------------- - inline - unsigned int Tree::nodeOffset(NodeData const & rNode) const - { - unsigned int nOffset = ROOT + (&rNode - &m_aNodes[0]); - OSL_ASSERT(isValidNode(nOffset)); - return nOffset; - } - -//----------------------------------------------------------------------------- -// helper for other impl classes -//----------------------------------------------------------------------------- -#if OSL_DEBUG_LEVEL > 0 - struct ElementHelper - { - static - com::sun::star::uno::Type getUnoType(rtl::Reference< ElementTree > const& aElement); - }; -#endif -//----------------------------------------------------------------------------- - } -//----------------------------------------------------------------------------- -} - -#endif // CONFIGMGR_CONFIGNODEIMPL_HXX_ |