configmgr/source/inc/change.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: change.hxx,v $
  10  * $Revision: 1.28 $
  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_CHANGE_HXX
  32 #define CONFIGMGR_CHANGE_HXX
  33 #if defined(_MSC_VER) && (_MSC_VER >= 1400)
  34 #pragma warning(disable : 4350) // behavior change: 'member1' called instead of 'member2'
  35 #endif
  36
  37 #include "valuenode.hxx"
  38 #include "treesegment.hxx"
  39 #include <sal/types.h>
  40 #include <rtl/ustring.hxx>
  41 #include <com/sun/star/uno/Sequence.hxx>
  42
  43 #ifndef INCLUDED_MAP
  44 #include <map>
  45 #define INCLUDED_MAP
  46 #endif
  47 #ifndef INCLUDED_MEMORY
  48 #include <memory>
  49 #define INCLUDED_MEMORY
  50 #endif
  51
  52 namespace configmgr
  53 {
  54
  55     namespace uno = com::sun::star::uno;
  56
  57     class Change;
  58     class SubtreeChange;
  59     class ValueChange;
  60     class AddNode;
  61     class RemoveNode;
  62
  63
  64     //==========================================================================
  65     //= ChangeTreeAction
  66     //==========================================================================
  67     struct ChangeTreeAction
  68     {
  69         virtual void handle(ValueChange const& aValueNode) = 0;
  70         virtual void handle(AddNode const& aAddNode) = 0;
  71         virtual void handle(RemoveNode const& aRemoveNode) = 0;
  72         virtual void handle(SubtreeChange const& aSubtree) = 0;
  73
  74         void applyToChange(Change const& aChange);
  75         void applyToChildren(SubtreeChange const& aSubtree);
  76     protected:
  77         virtual ~ChangeTreeAction() {}
  78     };
  79
  80     struct ChangeTreeModification
  81     {
  82         virtual void handle(ValueChange& aValueNode) = 0;
  83         virtual void handle(AddNode& aAddNode) = 0;
  84         virtual void handle(RemoveNode& aRemoveNode) = 0;
  85         virtual void handle(SubtreeChange& aSubtree) = 0;
  86
  87         void applyToChange(Change& aChange);
  88         void applyToChildren(SubtreeChange& aSubtree);
  89     protected:
  90         virtual ~ChangeTreeModification() {}
  91     };
  92
  93     //==========================================================================
  94     //= Change
  95     //==========================================================================
  96     class Change
  97     {
  98     protected:
  99         rtl::OUString m_aName;
 100         bool m_bIsToDefault;
 101
 102         void swap(Change& aOther);
 103
 104     public:
 105         explicit
 106         Change(rtl::OUString const& _rName, bool _bToDefault)
 107         : m_aName(_rName)
 108         , m_bIsToDefault(_bToDefault)
 109         {}
 110
 111         virtual ~Change() {}
 112
 113         rtl::OUString getNodeName() const { return m_aName; }
 114         void setNodeName(const rtl::OUString &aName) {m_aName = aName;}
 115
 116         bool isToDefault() const { return m_bIsToDefault;  }
 117
 118         Change* getSubChange(rtl::OUString const& _rName) { return doGetChild(_rName); }
 119         Change const* getSubChange(rtl::OUString const& _rName) const { return doGetChild(_rName); }
 120
 121         virtual void dispatch(ChangeTreeAction& anAction) const = 0;
 122         virtual void dispatch(ChangeTreeModification& anAction) = 0;
 123
 124         virtual std::auto_ptr<Change> clone() const = 0;
 125
 126     private:
 127         virtual Change* doGetChild(rtl::OUString const& ) const { return 0; }
 128     };
 129
 130     //==========================================================================
 131     //= ValueChange
 132     //==========================================================================
 133     class ValueChange : public Change
 134     {
 135     public:
 136         struct SetToDefault {};
 137         enum Mode { wasDefault, changeValue, setToDefault, changeDefault };
 138
 139     private:
 140         uno::Type                   m_aValueType;
 141         uno::Any                    m_aValue;
 142         uno::Any                    m_aOldValue;
 143         node::Attributes        m_aAttributes;
 144         Mode                        m_eMode;
 145     public:
 146         ValueChange(
 147             rtl::OUString const& _rName,
 148             const node::Attributes& _rAttributes,
 149             Mode aMode,
 150             uno::Any const & aNewValue,
 151             uno::Any const & aOldValue = uno::Any());
 152
 153         virtual std::auto_ptr<Change> clone() const;
 154
 155         bool isChange() const;
 156
 157         uno::Type       getValueType() const { return m_aValueType; }
 158
 159         uno::Any        getNewValue() const { return m_aValue; }
 160         uno::Any        getOldValue() const { return m_aOldValue; }
 161
 162         void            setNewValue(const uno::Any& _rNewVal);
 163         void            setNewValue(const uno::Any& _rNewVal, Mode aMode)
 164         { setNewValue(_rNewVal); m_eMode = aMode;}
 165
 166         bool isReplacedValue()   const {return m_aAttributes.isReplacedForUser();}
 167         bool isLocalizedValue()  const {return m_aAttributes.isLocalized();}
 168
 169         Mode getMode() const { return m_eMode; }
 170
 171         const node::Attributes& getAttributes() const {return m_aAttributes;}
 172
 173         void applyChangeNoRecover(ValueNode& aNode) const;
 174
 175         virtual void dispatch(ChangeTreeAction& anAction) const { anAction.handle(*this); }
 176         virtual void dispatch(ChangeTreeModification& anAction) { anAction.handle(*this); }
 177
 178         friend class ApplyValueChange;
 179     };
 180
 181     //==========================================================================
 182     //= AddNode
 183     //==========================================================================
 184     class AddNode : public Change
 185     {
 186         rtl::Reference< data::TreeSegment > m_aOwnNewNode;
 187         rtl::Reference< data::TreeSegment > m_aOwnOldNode;
 188         sharable::TreeFragment *        m_aInsertedTree;
 189         bool                            m_bReplacing;
 190
 191     private:
 192         void operator=(AddNode const&); // not implemented
 193
 194         // needed for clone()
 195         AddNode(AddNode const&);
 196     public:
 197         AddNode(rtl::Reference< data::TreeSegment > const & _aAddedTree, rtl::OUString const& _rName, bool _bToDefault);
 198         ~AddNode();
 199
 200         virtual std::auto_ptr<Change> clone() const;
 201
 202         /// marks this as not merely adding a node but replacing another
 203         void setReplacing() { m_bReplacing = true; }
 204         /// is this  not merely adding a node but replacing another ?
 205         bool isReplacing() const { return m_bReplacing; }
 206
 207         /// has this been applied and inserted
 208         bool wasInserted() const { return m_aInsertedTree != NULL; }
 209
 210         /** returns the node this change represents, even if this node does not own the new Node object any more.
 211             This is somewhat dangerous if the node referenced by this object dies before the object itself does.<BR>
 212             In this case all calls to this method will return nonsense. This case can be detected by testing
 213             whether <method>getAddedNode</method> returns NULL.
 214         */
 215         sharable::TreeFragment *   getInsertedTree()    const { return m_aInsertedTree; }
 216
 217         /** returns the node this change represents; The Node object is owned by this change until
 218             <method>releaseAddedNode</method> is called.<BR>
 219             After ownership is lost this method returns NULL.
 220         */
 221         sharable::TreeFragment const * getNewTreeData() const  { return m_aOwnNewNode.is() ? m_aOwnNewNode->fragment : 0; }
 222
 223         /** returns the node the change represents. .
 224         */
 225         rtl::Reference< data::TreeSegment > getNewTree() const   { return m_aOwnNewNode; }
 226
 227         /** returns the node the change represents, and releases ownership of it. This means that
 228             afterwards <method>getAddedNode</method> will return NULL. This change object keeps a reference
 229             to the node though which can be retrieved using <method>getAddedNode_unsafe</method>.
 230         */
 231         void clearNewTree() { m_aOwnNewNode.clear(); }
 232
 233         /** .
 234         */
 235         void setInsertedAddress(sharable::TreeFragment * const & _aInsertedAddress);
 236
 237
 238         /** returns the node this change replaces, ihe Node object is owned by this change.
 239             After ownership is lost this method returns NULL.
 240         */
 241         sharable::TreeFragment const * getReplacedTreeData() const      { return m_aOwnOldNode.is() ? m_aOwnOldNode->fragment : 0; }
 242
 243         /** returns the node the change replaces.
 244         */
 245         rtl::Reference< data::TreeSegment > getReplacedTree() const     { return m_aOwnOldNode; }
 246
 247         /** forgets about the node the change replaces
 248         */
 249         void clearReplacedTree() { m_aOwnOldNode.clear(); }
 250
 251         void takeReplacedTree(rtl::Reference< data::TreeSegment > const& _aTree);
 252
 253         virtual void dispatch(ChangeTreeAction& anAction) const { anAction.handle(*this); }
 254         virtual void dispatch(ChangeTreeModification& anAction) { anAction.handle(*this); }
 255     };
 256
 257     //==========================================================================
 258     //= RemoveNode
 259     //==========================================================================
 260     class RemoveNode : public Change
 261     {
 262     protected:
 263         rtl::Reference< data::TreeSegment > m_aOwnOldNode;
 264         bool                            m_bIsToDefault;
 265
 266     private:
 267         RemoveNode& operator=(const RemoveNode&); // not implemented
 268         // needed for clone()
 269         RemoveNode(const RemoveNode&);
 270     public:
 271         explicit
 272         RemoveNode(rtl::OUString const& _rName, bool _bToDefault);
 273         ~RemoveNode();
 274
 275         virtual std::auto_ptr<Change> clone() const;
 276
 277         virtual void dispatch(ChangeTreeAction& anAction) const { anAction.handle(*this); }
 278         virtual void dispatch(ChangeTreeModification& anAction) { anAction.handle(*this); }
 279
 280         /** returns the node this change removes, ihe Node object is owned by this change.
 281             After ownership is lost this method returns NULL.
 282         */
 283         sharable::TreeFragment const * getRemovedTreeData() const { return m_aOwnOldNode.is() ? m_aOwnOldNode->fragment : 0; }
 284         /** returns the node the change removes.
 285         */
 286         rtl::Reference< data::TreeSegment > getRemovedTree()            const   { return m_aOwnOldNode; }
 287
 288         /** forgets about the node the change removes, returning the previous setting with ownership
 289         */
 290         void clearRemovedTree() { m_aOwnOldNode.clear(); }
 291
 292         void takeRemovedTree(rtl::Reference< data::TreeSegment > const & _aTree);
 293     };
 294
 295     //==========================================================================
 296     //= SubtreeChange
 297     //==========================================================================
 298     class SubtreeChange : public Change
 299     {
 300     protected:
 301         typedef ::std::map< ::rtl::OUString,Change* > Children;
 302         Children                                        m_aChanges;
 303         ::rtl::OUString                         m_sTemplateName;                        /// path of the template for child instantiation
 304         ::rtl::OUString                         m_sTemplateModule;                      /// module of the template for child instantiation
 305         node::Attributes                m_aAttributes;
 306
 307         // don't create copy ops automatically
 308         SubtreeChange(const SubtreeChange&);
 309         void operator=(SubtreeChange&);
 310
 311               using Change::swap;
 312
 313     public:
 314         class ChildIterator;
 315         ChildIterator begin() const throw();
 316         ChildIterator end() const throw();
 317
 318         class MutatingChildIterator;
 319         MutatingChildIterator begin_changes() throw();
 320         MutatingChildIterator end_changes() throw();
 321
 322         friend class MutatingChildIterator;
 323     public:
 324         SubtreeChange(const rtl::OUString& _rName,
 325                       const node::Attributes& _rAttr,
 326                       bool _bToDefault = false)
 327         : Change(_rName,_bToDefault)
 328         , m_aAttributes(_rAttr)
 329         {
 330             m_aAttributes.markAsDefault(_bToDefault);
 331         }
 332
 333         SubtreeChange(const rtl::OUString& _rName,
 334                       const rtl::OUString& _rTemplateName,
 335                       const rtl::OUString& _rTemplateModule,
 336                       const node::Attributes& _rAttr,
 337                       bool _bToDefault = false)
 338         : Change(_rName,_bToDefault)
 339         , m_sTemplateName(_rTemplateName)
 340         , m_sTemplateModule(_rTemplateModule)
 341         , m_aAttributes(_rAttr)
 342         {
 343             m_aAttributes.markAsDefault(_bToDefault);
 344         }
 345
 346         SubtreeChange(const ISubtree& _rTree, bool _bToDefault = false)
 347         : Change(_rTree.getName(),_bToDefault)
 348         , m_sTemplateName(_rTree.getElementTemplateName())
 349         , m_sTemplateModule(_rTree.getElementTemplateModule())
 350         , m_aAttributes(_rTree.getAttributes())
 351         {
 352             m_aAttributes.markAsDefault(_bToDefault);
 353         }
 354
 355         SubtreeChange(const SubtreeChange& _rChange, treeop::NoChildCopy)
 356         : Change(_rChange)
 357         , m_sTemplateName(_rChange.getElementTemplateName())
 358         , m_sTemplateModule(_rChange.getElementTemplateModule())
 359         , m_aAttributes(_rChange.getAttributes())
 360         {}
 361
 362         ~SubtreeChange();
 363
 364         SubtreeChange(const SubtreeChange&, treeop::DeepChildCopy);
 365
 366         virtual std::auto_ptr<Change> clone() const;
 367
 368         void swap(SubtreeChange& aOther);
 369
 370         bool isReplacedNode()       const { return m_aAttributes.isReplacedForUser();  }
 371         bool isLocalizedContainer() const { return m_aAttributes.isLocalized(); }
 372
 373         const node::Attributes& getAttributes() const {return m_aAttributes;}
 374
 375         bool                    isSetNodeChange() const { return m_sTemplateName.getLength() != 0; }
 376
 377         rtl::OUString   getElementTemplateName() const { return m_sTemplateName; }
 378         rtl::OUString   getElementTemplateModule() const { return m_sTemplateModule; }
 379
 380         void                    setElementTemplate(const rtl::OUString& _rName, const rtl::OUString& _rModule)
 381         { m_sTemplateName = _rName; m_sTemplateModule = _rModule; }
 382
 383         sal_Int32                       size() const { return m_aChanges.size(); }
 384         uno::Sequence< rtl::OUString >  elementNames() const;
 385
 386         void                                    addChange(std::auto_ptr<Change> aChange);
 387         ::std::auto_ptr<Change> removeChange(rtl::OUString const& _rName);
 388
 389         Change* getChange(rtl::OUString const& _rName);
 390         Change const* getChange(rtl::OUString const& _rName) const;
 391
 392         virtual void dispatch(ChangeTreeAction& _anAction) const;
 393         virtual void dispatch(ChangeTreeModification& _anAction);
 394
 395         void forEachChange(ChangeTreeAction& _anAction) const;
 396         void forEachChange(ChangeTreeModification& _anAction);
 397
 398     private:
 399         virtual Change* doGetChild(rtl::OUString const& _rName) const;
 400     };
 401
 402     /** iterates through all children of a <type>SubtreeChange</type>. Every non-const action on the object
 403         which is beeing iterated invalidates the iterator.
 404         <BR>
 405         beware of the lifetime of the tree change object : it has to live as long as the iterator does (at least) !!
 406     */
 407     class SubtreeChange::ChildIterator
 408     {
 409     protected:
 410         uno::Sequence< rtl::OUString >  m_aNames;
 411         const SubtreeChange*                    m_pTree;
 412         sal_Int32                                               m_nPos;
 413
 414         friend class SubtreeChange;
 415         struct EndPos { };
 416         ChildIterator(const SubtreeChange* _pTree, struct EndPos);
 417
 418         inline sal_Bool isValid() const { return m_nPos >= 0 && m_nPos < m_aNames.getLength(); }
 419
 420     public:
 421         ChildIterator(const SubtreeChange* _pTree);
 422
 423         const Change& operator*() const;
 424         const Change* operator->() const;
 425
 426         ChildIterator& operator++();
 427         ChildIterator operator++(int) { ChildIterator ret(*this); ++*this; return ret; }
 428
 429         ChildIterator& operator--();
 430         ChildIterator operator--(int) { ChildIterator ret(*this); --*this; return ret; }
 431
 432         friend bool operator==(ChildIterator const& lhs, ChildIterator const& rhs);
 433         friend bool operator!=(ChildIterator const& lhs, ChildIterator const& rhs) { return !(lhs == rhs); }
 434     };
 435
 436     /** iterates through all children of a <type>SubtreeChange</type>. Every non-const action on the object
 437         which is beeing iterated invalidates the iterator.
 438         <BR>
 439         beware of the lifetime of the tree change object : it has to live as long as the iterator does (at least) !!
 440     */
 441     class SubtreeChange::MutatingChildIterator
 442     {
 443     protected:
 444         SubtreeChange::Children::iterator m_aBaseIter;
 445
 446         friend class SubtreeChange;
 447         MutatingChildIterator(SubtreeChange::Children::iterator aBase) : m_aBaseIter(aBase) {};
 448
 449     public:
 450         Change& current() const { return *m_aBaseIter->second; }
 451
 452         Change& operator*() const { return current(); }
 453         Change* operator->() const { return &current(); }
 454
 455         MutatingChildIterator& operator++()             { ++m_aBaseIter; return *this; }
 456         MutatingChildIterator operator++(int)   { return MutatingChildIterator(m_aBaseIter++); }
 457
 458         MutatingChildIterator& operator--()             { ++m_aBaseIter; return *this; }
 459         MutatingChildIterator operator--(int)   { return MutatingChildIterator(m_aBaseIter++); }
 460
 461         friend bool operator==(MutatingChildIterator const& lhs, MutatingChildIterator const& rhs)
 462         { return lhs.m_aBaseIter == rhs.m_aBaseIter; }
 463         friend bool operator!=(MutatingChildIterator const& lhs, MutatingChildIterator const& rhs) { return !(lhs == rhs); }
 464     };
 465     //==========================================================================
 466     //= SubtreeChangeReferrer
 467     //==========================================================================
 468     /** a specialized SubtreeChange, which, upon desctruction, does not delete the changes
 469         it holds
 470
 471         <BR>
 472         This implies that when using this class, you have to beware of the lifetime of the involved objects
 473     */
 474     class SubtreeChangeReferrer : public SubtreeChange
 475     {
 476         // no explicit construction
 477         SubtreeChangeReferrer() : SubtreeChange(::rtl::OUString(), node::Attributes()) { }
 478
 479     public:
 480         SubtreeChangeReferrer(const SubtreeChange& _rSource);
 481         ~SubtreeChangeReferrer();
 482     };
 483
 484 ////////////////////////////////////////////////////////////////////////////////
 485     //==========================================================================
 486     extern bool isLocalizedValueSet(SubtreeChange const& _aSubtree);
 487     extern bool isValueSet(SubtreeChange const& _aSubtree);
 488
 489     //==========================================================================
 490     //= inlines
 491     //==========================================================================
 492     inline void ChangeTreeAction::applyToChange(Change const& aChange)
 493     { aChange.dispatch(*this); }
 494     inline void ChangeTreeAction::applyToChildren(SubtreeChange const& aSubtree)
 495     { aSubtree.forEachChange(*this); }
 496
 497     inline void ChangeTreeModification::applyToChange(Change& aChange)
 498     { aChange.dispatch(*this); }
 499     inline void ChangeTreeModification::applyToChildren(SubtreeChange& aSubtree)
 500     { aSubtree.forEachChange(*this); }
 501
 502 ////////////////////////////////////////////////////////////////////////////////
 503
 504 } // namespace configmgr
 505
 506 #endif
 507