configmgr/source/treemgr/nodechange.cxx

   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: nodechange.cxx,v $
  10  * $Revision: 1.13 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "nodechange.hxx"
  35 #include "nodechangeimpl.hxx"
  36 #include "nodechangeinfo.hxx"
  37
  38 #include "noderef.hxx"
  39 #include "tree.hxx"
  40
  41 #include <algorithm>
  42 #include <osl/diagnose.h>
  43
  44 namespace configmgr
  45 {
  46     namespace configuration
  47     {
  48
  49 //-----------------------------------------------------------------------------
  50 // NodeChange handle class
  51 //-----------------------------------------------------------------------------
  52
  53 //-----------------------------------------------------------------------------
  54 inline void NodeChange::init()
  55 {
  56     if (m_pImpl) m_pImpl->acquire();
  57 }
  58 inline void NodeChange::deinit()
  59 {
  60     if (m_pImpl) m_pImpl->release();
  61 }
  62
  63 //-----------------------------------------------------------------------------
  64 NodeChange::NodeChange()
  65 : m_pImpl(0)
  66 {
  67 }
  68 //-----------------------------------------------------------------------------
  69
  70 NodeChange::NodeChange(NodeChangeImpl* pImpl)
  71 : m_pImpl(pImpl)
  72 {
  73     init();
  74 }
  75 //-----------------------------------------------------------------------------
  76
  77 NodeChange::NodeChange(NodeChange const& rOther)
  78 : m_pImpl(rOther.m_pImpl)
  79 {
  80     init();
  81 }
  82 //-----------------------------------------------------------------------------
  83
  84 NodeChange& NodeChange::operator=(NodeChange const& rOther)
  85 {
  86     NodeChange(rOther).swap(*this);
  87     return *this;
  88 }
  89 //-----------------------------------------------------------------------------
  90
  91 void NodeChange::swap(NodeChange& rOther)
  92 {
  93     std::swap(m_pImpl,rOther.m_pImpl);
  94 }
  95 //-----------------------------------------------------------------------------
  96
  97 NodeChange::~NodeChange()
  98 {
  99     deinit();
 100 }
 101 //-----------------------------------------------------------------------------
 102
 103 bool NodeChange::maybeChange() const
 104 {
 105     return m_pImpl && m_pImpl->isChange(true);
 106 }
 107 //-----------------------------------------------------------------------------
 108
 109 bool NodeChange::isChange() const
 110 {
 111     return m_pImpl && m_pImpl->isChange(false);
 112 }
 113 //-----------------------------------------------------------------------------
 114
 115 sal_uInt32 NodeChange::getChangeInfos(NodeChangesInformation& _rInfos) const
 116 {
 117     sal_uInt32 nCount = 0;
 118     if (m_pImpl)
 119     {
 120         sal_uInt32 nChanges = m_pImpl->getChangeDataCount();
 121
 122         for (sal_uInt32 ix = 0; ix < nChanges; ++ix)
 123         {
 124         NodeChangeInformation aSingleInfo;
 125             aSingleInfo.change.type = NodeChangeData::eNoChange;
 126
 127             m_pImpl->fillChangeInfo(aSingleInfo,ix);
 128
 129             if ( !aSingleInfo.isEmptyChange() )
 130             {
 131                 _rInfos.push_back(aSingleInfo);
 132                 ++nCount;
 133             }
 134         }
 135     }
 136
 137     return nCount;
 138 }
 139 //-----------------------------------------------------------------------------
 140
 141 bool NodeChange::getChangeLocation(NodeChangeLocation& rLoc) const
 142 {
 143     return m_pImpl && m_pImpl->fillChangeLocation(rLoc);
 144 }
 145
 146 //-----------------------------------------------------------------------------
 147
 148 // retrieve the tree where the change is actually taking place
 149 rtl::Reference< Tree > NodeChange::getAffectedTree() const
 150 {
 151     if (this->maybeChange())
 152         return m_pImpl->getTargetTree().get();
 153     else
 154         return NULL;
 155 }
 156 //-----------------------------------------------------------------------------
 157
 158 // retrieve the tree where the change is actually taking place
 159 NodeRef NodeChange::getAffectedNode() const
 160 {
 161     if (this->maybeChange())
 162     {
 163         rtl::Reference<Tree> aTree = m_pImpl->getTargetTree();
 164         unsigned int nOffset = m_pImpl->getTargetNode();
 165
 166         OSL_ASSERT(aTree.is() && aTree->isValidNode(nOffset));
 167
 168         if (aTree.is() && nOffset)
 169             return aTree->getNode(nOffset);
 170     }
 171     return NodeRef();
 172 }
 173 //-----------------------------------------------------------------------------
 174
 175 NodeChange& NodeChange::test()
 176 {
 177     if (m_pImpl) m_pImpl->test();
 178     return *this;
 179 }
 180
 181 //-----------------------------------------------------------------------------
 182 NodeChange const& NodeChange::test() const
 183 {
 184     if (m_pImpl) m_pImpl->test();
 185     return *this;
 186 }
 187
 188 //-----------------------------------------------------------------------------
 189 NodeChange& NodeChange::apply()
 190 {
 191     if (m_pImpl) m_pImpl->apply();
 192     return *this;
 193 }
 194
 195 //-----------------------------------------------------------------------------
 196 NodeChange const& NodeChange::apply() const
 197 {
 198     if (m_pImpl) m_pImpl->apply();
 199     return *this;
 200 }
 201
 202 //-----------------------------------------------------------------------------
 203 // NodeChanges collection
 204 //-----------------------------------------------------------------------------
 205
 206 NodeChanges::NodeChanges()
 207 : m_aChanges()
 208 {
 209 }
 210 //-----------------------------------------------------------------------------
 211
 212 bool NodeChanges::isEmpty() const
 213 {
 214     return m_aChanges.empty();
 215 }
 216 //-----------------------------------------------------------------------------
 217
 218 /// predicate for compact
 219
 220 static bool isEmptyChange(NodeChange const& aChange)
 221 {
 222     return !aChange.maybeChange();
 223 }
 224 //-----------------------------------------------------------------------------
 225
 226
 227 NodeChanges& NodeChanges::compact()
 228 {
 229     m_aChanges.erase( std::remove_if(begin(),end(),isEmptyChange), end() );
 230     return *this;
 231 }
 232 //-----------------------------------------------------------------------------
 233
 234 void NodeChanges::implTest() const
 235 {
 236     for(std::vector<NodeChange>::const_iterator it = begin(), stop = end(); it != stop; ++it)
 237     {
 238         it ->test();
 239     }
 240 }
 241 //-----------------------------------------------------------------------------
 242 /** insert a change into this collection
 243 */
 244 void NodeChanges::add(NodeChange const& aChange)
 245 {
 246     m_aChanges.push_back(aChange);
 247 }
 248
 249 //-----------------------------------------------------------------------------
 250
 251 /** removes a change to <var>aNode</var> from this collection (if there is one)
 252 void NodeChanges::reset(Node const& aNode)
 253 {
 254 }
 255 */
 256
 257 sal_uInt32 NodeChanges::getChangesInfos(NodeChangesInformation& _rInfos) const
 258 {
 259     if (isEmpty()) return 0;
 260
 261     _rInfos.reserve(_rInfos.size() + this->getCount());
 262
 263     sal_Int32 nResult = 0;
 264     for (std::vector<NodeChange>::const_iterator it = begin(); it != end(); ++it)
 265     {
 266         nResult += it->getChangeInfos(_rInfos);
 267     }
 268
 269     return nResult;
 270 }
 271 //-----------------------------------------------------------------------------
 272 //-----------------------------------------------------------------------------
 273
 274     }
 275 }
 276