configmgr/source/inc/node.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: node.hxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef INCLUDED_SHARABLE_NODE_HXX
  32 #define INCLUDED_SHARABLE_NODE_HXX
  33
  34 #include "rtl/ustring.hxx"
  35
  36 #include "flags.hxx"
  37 #include "anydata.hxx"
  38
  39 namespace configmgr
  40 {
  41 //-----------------------------------------------------------------------------
  42     namespace node { struct Attributes; }
  43 //-----------------------------------------------------------------------------
  44     namespace sharable
  45     {
  46         struct  TreeFragment;
  47         union   Node;
  48     //-----------------------------------------------------------------------------
  49         struct NodeInfo
  50         {
  51             rtl_uString *            name;
  52             sal_uInt16          parent; // always counts backwards
  53             sal_uInt8    flags;
  54             sal_uInt8    type;   // contains discriminator for union
  55
  56             rtl::OUString       getName() const;
  57             node::Attributes    getNodeInfoAttributes() const;
  58             bool isDefault() const;
  59             bool isLocalized() const;
  60
  61             void markAsDefault(bool bDefault = true);
  62         };
  63     //-----------------------------------------------------------------------------
  64         struct GroupNode
  65         {
  66             NodeInfo info;
  67             sal_uInt16   numDescendants;   // = number of descendants
  68
  69             bool hasDefaultsAvailable()   const;
  70
  71             Node * getFirstChild()  const;
  72             Node * getNextChild(Node * child) const;
  73             Node * getChild(rtl::OUString const & name) const;
  74
  75             static inline GroupNode * from(Node * node);
  76         };
  77     //-----------------------------------------------------------------------------
  78         struct SetNode
  79         {
  80
  81             NodeInfo info;
  82             sal_uInt8 *  elementType; // points to template [MM:SetNode *?]
  83             TreeFragment *     elements;    // points to first element (TreeFragmentHeader)
  84
  85             rtl::OUString getElementTemplateName() const;
  86             rtl::OUString getElementTemplateModule() const;
  87
  88             TreeFragment * getFirstElement() const;
  89             TreeFragment * getNextElement(TreeFragment * _pElement) const;
  90             TreeFragment * getElement(rtl::OUString const & name) const;
  91
  92             void addElement(TreeFragment * newElement);
  93             TreeFragment * removeElement(rtl::OUString const & name);
  94
  95             static inline SetNode * from(Node * node);
  96
  97             // low-level helper for template data abstraction
  98             static
  99             sal_uInt8 * allocTemplateData(const rtl::OUString &rName,
 100                                       const rtl::OUString &rModule);
 101             static
 102             sal_uInt8 * copyTemplateData(sal_uInt8 * _aTemplateData);
 103             static
 104             void releaseTemplateData(sal_uInt8 * _aTemplateData);
 105         };
 106     //-----------------------------------------------------------------------------
 107         struct ValueNode
 108         {
 109             NodeInfo info;
 110             AnyData  value;
 111             AnyData  defaultValue;
 112
 113             bool isNull()       const;
 114             bool hasUsableDefault()   const;
 115
 116             com::sun::star::uno::Any    getValue() const;
 117             com::sun::star::uno::Type   getValueType() const;
 118             com::sun::star::uno::Any    getUserValue() const;
 119             com::sun::star::uno::Any    getDefaultValue() const;
 120
 121             void setValue(com::sun::star::uno::Any const & newValue);
 122             void setToDefault();
 123             void changeDefault(com::sun::star::uno::Any const & newDefault);
 124
 125             static inline ValueNode * from(Node * node);
 126
 127         private:
 128             void releaseValue();
 129             sal_uInt8 adaptType(com::sun::star::uno::Any const & newValue);
 130         };
 131     //-----------------------------------------------------------------------------
 132         // TODO: optimized representation of localized values (now as set; mapping locale->element-name)
 133         // TODO (?): better representation of sets of values
 134     //-----------------------------------------------------------------------------
 135         union Node
 136         {
 137             NodeInfo info;
 138             GroupNode group;
 139             SetNode   set;
 140             ValueNode value;
 141
 142             // info access
 143             bool isNamed(rtl::OUString const & _aName) const;
 144             rtl::OUString       getName() const;
 145             node::Attributes    getAttributes() const;
 146             bool isDefault() const;
 147
 148             // type checks
 149             bool isGroup()  const  { return typeIs (data::Type::nodetype_group); }
 150             bool isSet()    const  { return typeIs (data::Type::nodetype_set); }
 151             bool isValue()  const  { return typeIs (data::Type::nodetype_value); }
 152
 153             // checked access
 154             inline GroupNode       * groupData();
 155             inline GroupNode const * groupData() const;
 156             inline SetNode         * setData();
 157             inline SetNode   const * setData()   const;
 158             inline ValueNode       * valueData();
 159             inline ValueNode const * valueData() const;
 160
 161             // navigation
 162             bool isFragmentRoot() const;
 163 #if OSL_DEBUG_LEVEL > 0
 164             Node        * getParentNode();
 165             Node const  * getParentNode() const;
 166 #endif
 167             TreeFragment        * getTreeFragment();
 168             TreeFragment const  * getTreeFragment() const;
 169
 170             Node * getSubnode(rtl::OUString const & name);
 171
 172         private:
 173             bool typeIs(data::Type::Type eType) const
 174                 { return (info.type & data::Type::mask_nodetype) == eType; }
 175         };
 176
 177     //-----------------------------------------------------------------------------
 178         inline GroupNode * GroupNode::from(Node * node)
 179         { return node == 0 ? 0 : node->groupData(); }
 180
 181         inline SetNode * SetNode::from(Node * node)
 182         { return node == 0 ? 0 : node->setData(); }
 183
 184         inline ValueNode * ValueNode::from(Node * node)
 185         { return node == 0 ? 0 : node->valueData(); }
 186
 187         inline GroupNode       * Node::groupData()
 188             { return isGroup() ? &this->group : NULL; }
 189         inline GroupNode const * Node::groupData() const
 190             { return isGroup() ? &this->group : NULL; }
 191         inline SetNode       * Node::setData()
 192             { return isSet() ? &this->set : NULL; }
 193         inline SetNode const * Node::setData()   const
 194             { return isSet() ? &this->set : NULL; }
 195         inline ValueNode       * Node::valueData()
 196             { return isValue() ? &this->value : NULL; }
 197         inline ValueNode const * Node::valueData() const
 198             { return isValue() ? &this->value : NULL; }
 199
 200         inline Node * node(ValueNode * pNode)
 201         { return reinterpret_cast<Node*>(pNode); }
 202         inline Node * node(GroupNode * pNode)
 203         { return reinterpret_cast<Node*>(pNode); }
 204         inline Node * node(SetNode * pNode)
 205         { return reinterpret_cast<Node*>(pNode); }
 206
 207         inline Node const * node(ValueNode const* pNode)
 208         { return reinterpret_cast<Node const*>(pNode); }
 209         inline Node const * node(GroupNode const* pNode)
 210         { return reinterpret_cast<Node const*>(pNode); }
 211         inline Node const * node(SetNode const* pNode)
 212         { return reinterpret_cast<Node const*>(pNode); }
 213     //-----------------------------------------------------------------------------
 214         inline Node & node(ValueNode & pNode)
 215         { return reinterpret_cast<Node&>(pNode); }
 216         inline Node & node(GroupNode & pNode)
 217         { return reinterpret_cast<Node&>(pNode); }
 218         inline Node & node(SetNode & pNode)
 219         { return reinterpret_cast<Node&>(pNode); }
 220
 221         inline Node const & node(ValueNode const& pNode)
 222         { return reinterpret_cast<Node const&>(pNode); }
 223         inline Node const & node(GroupNode const& pNode)
 224         { return reinterpret_cast<Node const&>(pNode); }
 225         inline Node const & node(SetNode const& pNode)
 226         { return reinterpret_cast<Node const&>(pNode); }
 227     //-----------------------------------------------------------------------------
 228     }
 229 //-----------------------------------------------------------------------------
 230 }
 231
 232 #endif // INCLUDED_SHARABLE_NODE_HXX