configmgr/source/treemgr/nodechangeimpl.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: nodechangeimpl.hxx,v $
  10  * $Revision: 1.14 $
  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 CONFIGMGR_CONFIGCHANGEIMPL_HXX_
  32 #define CONFIGMGR_CONFIGCHANGEIMPL_HXX_
  33
  34 #include "configexcept.hxx"
  35 #include "configpath.hxx"
  36 #include "viewaccess.hxx"
  37 #include <rtl/ref.hxx>
  38 #include <salhelper/simplereferenceobject.hxx>
  39 #include "utility.hxx"
  40
  41 #ifndef INCLUDED_VECTOR
  42 #include <vector>
  43 #define INCLUDED_VECTOR
  44 #endif
  45
  46 #ifndef INCLUDED_MEMORY
  47 #include <memory>
  48 #define INCLUDED_MEMORY
  49 #endif
  50
  51 namespace configmgr
  52 {
  53     class ISubtree;
  54
  55     namespace view { class ViewTreeAccess; struct Node; struct GroupNode; struct SetNode; }
  56 //-----------------------------------------------------------------------------
  57     namespace configuration
  58     {
  59 //-----------------------------------------------------------------------------
  60
  61         class ValueMemberNode;
  62         class ValueMemberUpdate;
  63 //-----------------------------------------------------------------------------
  64         class NodeChangeData;
  65         class NodeChangeLocation;
  66         class NodeChangeInformation;
  67 //-----------------------------------------------------------------------------
  68         struct ElementTreeChange
  69         {
  70             Path::Component m_aElementName;
  71             rtl::Reference<ElementTree>  m_aAddedElement;
  72             rtl::Reference<ElementTree>  m_aRemovedElement;
  73
  74             ElementTreeChange(
  75                 Path::Component const& _aElementName,
  76                 rtl::Reference<ElementTree>  const& _aAddedElement,
  77                 rtl::Reference<ElementTree>  const& _aRemovedElement
  78              )
  79             : m_aElementName(_aElementName)
  80             , m_aAddedElement(_aAddedElement)
  81             , m_aRemovedElement(_aRemovedElement)
  82             {}
  83
  84             bool isChange() const
  85             {
  86                 return !!(m_aAddedElement != m_aRemovedElement);
  87             }
  88         };
  89 //-----------------------------------------------------------------------------
  90
  91
  92         /// represents a node position in some tree
  93         class NodeChangeImpl
  94         : public salhelper::SimpleReferenceObject
  95         {
  96         public:
  97             explicit
  98             NodeChangeImpl(bool bNoCheck = false);
  99
 100         public:
 101         // related/affected nodes and trees
 102             /// the tree within which the change occurs
 103             rtl::Reference<Tree> getTargetTree() const;
 104
 105             /// the node that is affected by the change
 106             unsigned int getTargetNode() const;
 107
 108         protected:
 109             /// setup the 'target' node that is to be affected or changed
 110             void setTarget(rtl::Reference<Tree> const& _aAffectedTree, unsigned int _nAffectedNode);
 111             void setTarget(view::Node _aAffectedNode);
 112
 113             view::ViewTreeAccess getTargetView();
 114         public:
 115         // getting information
 116             /*static const sal_uInt32*/ enum { scCommonBase = ~0u };
 117
 118             /// checks, if this represents an actual change - with or without requiring a preceding test
 119             bool isChange(bool bAllowUntested) const;
 120
 121             /// return the number of distict changes in this object
 122             sal_uInt32 getChangeDataCount() const;
 123
 124             /// fills in base change location, returns whether it is set
 125             bool fillChangeLocation(NodeChangeLocation& rChange, sal_uInt32 _ix = scCommonBase) const;
 126
 127             /// fills in pre- and post-change values, returns whether they may differ
 128             bool fillChangeData(NodeChangeData& rChange, sal_uInt32 _ix) const;
 129
 130             /// fills in change location and values, returns whether data may be changed
 131             bool fillChangeInfo(NodeChangeInformation& rChange, sal_uInt32 _ix) const;
 132
 133         /// test whether this really is a change to the stored 'changing' node
 134             void test();
 135
 136         /// apply this change to the stored 'changing' node
 137             void apply();
 138
 139         private:
 140         /// virtual hooks for some of the public methods
 141             /// return the number of distict changes in this object
 142             sal_uInt32 doGetChangeCount() const;
 143
 144             /// the path from base to 'changing' node
 145             virtual RelativePath doGetChangingNodePath(sal_uInt32 _ix) const = 0;
 146
 147             /// is the change really affecting a child (or children) of the affected node (true for values)
 148             virtual bool doIsChangingSubnode() const = 0;
 149
 150             /// checks, if this represents an actual change (given whether the change has been applied or not)
 151             virtual bool doIsChange() const = 0;
 152
 153             /// fills in pre- and post-change values, returns wether they differ
 154             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const = 0;
 155
 156             /// dry-check whether this is a change
 157             virtual void doTest( view::Node const& rTarget) = 0;
 158             /// do apply the actual change
 159             virtual void doApply( view::Node const& rTarget) = 0;
 160
 161         private:
 162             rtl::Reference<Tree> m_aAffectedTree;
 163             unsigned int m_nAffectedNode;
 164             sal_uInt16      m_nState;
 165
 166             void implApply();
 167             view::Node implGetTarget();
 168         };
 169 //-----------------------------------------------------------------------------
 170
 171         /// represents a node position in some tree
 172         class ValueChangeImpl
 173         : public NodeChangeImpl
 174         {
 175             rtl::OUString m_aName;
 176             com::sun::star::uno::Any m_aNewValue;
 177             com::sun::star::uno::Any m_aOldValue;
 178         public:
 179             explicit ValueChangeImpl();
 180             explicit ValueChangeImpl(com::sun::star::uno::Any const& aNewValue);
 181             explicit ValueChangeImpl(com::sun::star::uno::Any const& aNewValue, com::sun::star::uno::Any const& aOldValue);
 182             ~ValueChangeImpl();
 183
 184         public:
 185             /// setup the 'target' node that is to be affected or changed
 186             void setTarget(view::GroupNode const& _aParentNode, rtl::OUString const& sNodeName);
 187             void setTarget(rtl::Reference<Tree> const& aAffectedTree, unsigned int nParentNode, rtl::OUString const& sNodeName);
 188
 189         public:
 190             /// get the name of the value
 191             rtl::OUString getValueName() const { return m_aName; }
 192
 193             /// get the pre-change value (if known)
 194             com::sun::star::uno::Any getOldValue() const { return m_aOldValue; }
 195             /// get the post-change value (if known)
 196             com::sun::star::uno::Any getNewValue() const { return m_aNewValue; }
 197
 198         protected:
 199                      using NodeChangeImpl::setTarget;
 200         // override information items
 201             /// the path from base to 'affected' node - here is the name of the changing node
 202             virtual RelativePath doGetChangingNodePath(sal_uInt32 _ix) const;
 203
 204             /// is the change really affecting a child of the affected node (true here)
 205             virtual bool doIsChangingSubnode() const;
 206
 207         protected:
 208         // override change information items
 209             /// checks, if this represents an actual change (given whether the change has been applied or not)
 210             virtual bool doIsChange() const;
 211
 212             /// fills in pre- and post-change values, returns wether they differ
 213             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const = 0;
 214
 215         protected:
 216         // override apply functionality
 217             /// retrieve the old value from the given node
 218             virtual void doTest( view::Node const& rTarget);
 219             /// do apply the actual change
 220             virtual void doApply( view::Node const& rTarget);
 221
 222         protected:
 223         // new overrideables
 224             /// extract the pre-change value from the target context
 225             virtual void preCheckValue(ValueMemberNode& rNode, com::sun::star::uno::Any& rOld, com::sun::star::uno::Any& rNew);
 226             /// extract the post-change value from the target context
 227             virtual void postCheckValue(ValueMemberNode& rNode, com::sun::star::uno::Any& rNew);
 228             /// apply the new value to the target context
 229             virtual void doApplyChange(ValueMemberUpdate& rNode) = 0;
 230         };
 231 //-----------------------------------------------------------------------------
 232
 233         /// represents setting a value node to a given value
 234         class ValueReplaceImpl
 235         : public ValueChangeImpl
 236         {
 237         public:
 238             explicit ValueReplaceImpl(com::sun::star::uno::Any const& aNewValue);
 239             explicit ValueReplaceImpl(com::sun::star::uno::Any const& aNewValue, com::sun::star::uno::Any const& aOldValue);
 240
 241         protected:
 242             // implement: set the target to the new value
 243             virtual void doApplyChange( ValueMemberUpdate& rNode);
 244
 245             /// fills in pre- and post-change values, returns wether they differ
 246             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const;
 247
 248 //                      friend class SetReplaceValueImpl;
 249         };
 250 //-----------------------------------------------------------------------------
 251
 252         /// represents resetting a value node to its default value
 253         class ValueResetImpl
 254         : public ValueChangeImpl
 255         {
 256             bool m_bTargetIsDefault;
 257         public:
 258             explicit ValueResetImpl();
 259             explicit ValueResetImpl(com::sun::star::uno::Any const& aNewValue, com::sun::star::uno::Any const& aOldValue);
 260
 261         protected:
 262             // override: set the new value as well and check the default state
 263             virtual void preCheckValue(ValueMemberNode& rNode, com::sun::star::uno::Any& rOld, com::sun::star::uno::Any& rNew);
 264
 265             /// checks, if this represents an actual change (given whether the change has been applied or not)
 266             virtual bool doIsChange() const;
 267
 268             // implement: set the target to default
 269             virtual void doApplyChange( ValueMemberUpdate& rNode);
 270
 271             /// fills in pre- and post-change values, returns wether they differ
 272             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const;
 273         };
 274 //-----------------------------------------------------------------------------
 275
 276
 277         /// represents a change to a set (as a container)
 278         class SetChangeImpl
 279         : public NodeChangeImpl
 280         {
 281         public:
 282             explicit SetChangeImpl(bool bNoCheck = false);
 283
 284             using NodeChangeImpl::setTarget;
 285
 286         protected:
 287         /// virtual hooks for some of the public methods
 288             /// is the change really affecting a child of the affected node (false here)
 289             virtual bool doIsChangingSubnode() const;
 290         };
 291 //-----------------------------------------------------------------------------
 292         class SetElementFactory;
 293
 294         /// represents setting to its default state a set (as a container)
 295         class SetResetImpl
 296         : public SetChangeImpl
 297         {
 298             std::auto_ptr<ISubtree>             m_aDefaultData;
 299             SetElementFactory&                  m_rElementFactory;
 300             std::vector< ElementTreeChange >                         m_aTreeChanges;
 301         public:
 302             explicit SetResetImpl(
 303                 SetElementFactory& _rElementFactory,
 304                 std::auto_ptr<ISubtree> _pDefaultData,
 305                 bool _bNoCheck = false);
 306
 307             ~SetResetImpl();
 308
 309         protected:
 310         /// virtual hooks for some of the public methods
 311             /// retrieve the count of elements affected
 312             sal_uInt32 doGetChangeCount() const;
 313
 314             /// the path from base to 'affected' node
 315             virtual RelativePath doGetChangingNodePath(sal_uInt32 _ix) const;
 316
 317             /// checks, if this represents an actual change (given whether the change has been applied or not)
 318             virtual bool doIsChange() const;
 319             /// fills in pre- and post-change values, returns wether they differ
 320             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const;
 321
 322
 323             /// retrieve the old value from the given node
 324             virtual void doTest( view::Node const& rTarget);
 325             /// do apply the actual change
 326             virtual void doApply( view::Node const& rTarget);
 327         };
 328 //-----------------------------------------------------------------------------
 329
 330         /// represents a change to an element of a set (as a container)
 331         class SetElementChangeImpl
 332         : public SetChangeImpl
 333         {
 334             Path::Component m_aName;
 335         public:
 336             explicit SetElementChangeImpl(Path::Component const& aName, bool bNoCheck = false);
 337
 338             /// the name of the element being changed
 339             Path::Component getFullElementName() const { return m_aName; }
 340
 341             /// the name of the element being changed
 342             rtl::OUString getElementName() const { return m_aName.getName(); }
 343
 344         protected:
 345         /// virtual hooks for some of the public methods
 346             /// the path from base to 'affected' node - use element name
 347             virtual RelativePath doGetChangingNodePath(sal_uInt32 _ix) const;
 348
 349             /// retrieve the old value from the given node
 350             virtual void doTest( view::Node const& rTarget);
 351             /// do apply the actual change
 352             virtual void doApply( view::Node const& rTarget);
 353
 354         private:
 355             /// new overridable: retrieve the old value from a properly typed node
 356             virtual void doTestElement(view::SetNode const& _aNode, rtl::OUString const& aName) = 0;
 357             /// new overridable: apply the change to a properly typed node
 358             virtual void doApplyToElement(view::SetNode const& _aNode, rtl::OUString const& aName) = 0;
 359         };
 360 //-----------------------------------------------------------------------------
 361
 362         /// represents an insertion into a set of trees
 363         class SetInsertImpl
 364         : public SetElementChangeImpl
 365         {
 366             rtl::Reference<ElementTree> m_aNewTree;
 367         public:
 368             explicit SetInsertImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aNewTree, bool bNoCheck = false);
 369
 370         protected:
 371             /// checks, if this represents an actual change (given whether the change has been applied or not)
 372             virtual bool doIsChange() const;
 373             /// fills in pre- and post-change values, returns wether they differ
 374             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const;
 375
 376             /// new overridable: retrieve the old value from a properly typed node
 377             virtual void doTestElement(view::SetNode const& _aNode, rtl::OUString const& aName);
 378             /// new overridable: apply the change to a properly typed node
 379             virtual void doApplyToElement(view::SetNode const& _aNode, rtl::OUString const& aName);
 380         };
 381 //-----------------------------------------------------------------------------
 382
 383         /// represents a substitution within a set of trees
 384         class SetReplaceImpl
 385         : public SetElementChangeImpl
 386         {
 387             rtl::Reference<ElementTree> m_aNewTree;
 388             rtl::Reference<ElementTree> m_aOldTree;
 389         public:
 390             explicit SetReplaceImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aNewTree);
 391             explicit SetReplaceImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aNewTree, rtl::Reference<ElementTree> const& aOldTree);
 392
 393         protected:
 394             /// checks, if this represents an actual change (given whether the change has been applied or not)
 395             virtual bool doIsChange() const;
 396             /// fills in pre- and post-change values, returns wether they differ
 397             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const;
 398
 399             /// new overridable: retrieve the old value from a properly typed node
 400             virtual void doTestElement(view::SetNode const& _aNode, rtl::OUString const& aName);
 401             /// new overridable: apply the change to a properly typed node
 402             virtual void doApplyToElement(view::SetNode const& _aNode, rtl::OUString const& aName);
 403         };
 404 //-----------------------------------------------------------------------------
 405
 406         /// represents a removal from of a set of trees
 407         class SetRemoveImpl
 408         : public SetElementChangeImpl
 409         {
 410             rtl::Reference<ElementTree> m_aOldTree;
 411         public:
 412             explicit SetRemoveImpl(Path::Component const& aName);
 413             explicit SetRemoveImpl(Path::Component const& aName, rtl::Reference<ElementTree> const& aOldTree);
 414
 415         protected:
 416             /// checks, if this represents an actual change (given whether the change has been applied or not)
 417             virtual bool doIsChange() const;
 418             /// fills in pre- and post-change values, returns wether they differ
 419             virtual bool doFillChange(NodeChangeData& rChange, sal_uInt32 _ix) const;
 420
 421             /// new overridable: retrieve the old value from a properly typed node
 422             virtual void doTestElement(view::SetNode const& _aNode, rtl::OUString const& aName);
 423             /// new overridable: apply the change to a properly typed node
 424             virtual void doApplyToElement(view::SetNode const& _aNode, rtl::OUString const& aName);
 425         };
 426 //-----------------------------------------------------------------------------
 427
 428 //-----------------------------------------------------------------------------
 429     }
 430 }
 431
 432 #endif // CONFIGMGR_CONFIGCHANGEIMPL_HXX_