configmgr/source/treemgr/valuemembernode.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: valuemembernode.cxx,v $
  10  * $Revision: 1.11 $
  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 #include <stdio.h>
  34
  35 #include "valuemembernode.hxx"
  36 #include "nodeimplobj.hxx"
  37 #include "nodechangeimpl.hxx"
  38 #include "change.hxx"
  39 #include "valuenode.hxx"
  40 #include <osl/diagnose.h>
  41
  42 namespace configmgr
  43 {
  44     namespace configuration
  45     {
  46
  47 // helpers
  48 //-----------------------------------------------------------------------------
  49
  50 namespace
  51 {
  52
  53 //-----------------------------------------------------------------------------
  54 // internal accessors for direct updates to data
  55 //-----------------------------------------------------------------------------
  56
  57 inline
  58 void setOriginalValue(sharable::ValueNode * const& rOriginalAddress, com::sun::star::uno::Any const& aNewValue)
  59 {
  60     rOriginalAddress->setValue(aNewValue);
  61 }
  62 //-----------------------------------------------------------------------------
  63
  64 inline
  65 void setOriginalToDefault(sharable::ValueNode * const& rOriginalAddress)
  66 {
  67     rOriginalAddress->setToDefault();
  68 }
  69 } // anonymous namespace
  70
  71
  72 //-----------------------------------------------------------------------------
  73 // class ValueMemberNode
  74 //-----------------------------------------------------------------------------
  75
  76 ValueMemberNode::ValueMemberNode(sharable::ValueNode * node)
  77     : m_node(node)
  78     , m_xDeferredOperation()
  79 {}
  80 //-----------------------------------------------------------------------------
  81 ValueMemberNode::ValueMemberNode(rtl::Reference<DeferredImpl> const& _xDeferred) // must be valid
  82     : m_node( _xDeferred->getOriginalNode() )
  83     , m_xDeferredOperation(_xDeferred)
  84 {}
  85 //-----------------------------------------------------------------------------
  86
  87 ValueMemberNode::ValueMemberNode(ValueMemberNode const& rOriginal)
  88     : m_node(rOriginal.m_node)
  89     , m_xDeferredOperation(rOriginal.m_xDeferredOperation)
  90 {}
  91 //-----------------------------------------------------------------------------
  92 ValueMemberNode& ValueMemberNode::operator=(ValueMemberNode const& rOriginal)
  93 {
  94     m_node = rOriginal.m_node;
  95     m_xDeferredOperation    = rOriginal.m_xDeferredOperation;
  96     return *this;
  97 }
  98 //-----------------------------------------------------------------------------
  99 ValueMemberNode::~ValueMemberNode()
 100 {
 101 }
 102 //-----------------------------------------------------------------------------
 103
 104 bool ValueMemberNode::isValid() const
 105 {
 106     OSL_ASSERT( !m_xDeferredOperation.is() ||
 107                  m_node == m_xDeferredOperation->getOriginalNode());
 108
 109     return m_node != 0;
 110 }
 111 //-----------------------------------------------------------------------------
 112
 113 bool ValueMemberNode::hasChange() const
 114 {
 115     return m_xDeferredOperation.is()
 116            && m_xDeferredOperation->isChange();
 117 }
 118 //-----------------------------------------------------------------------------
 119
 120
 121 //-----------------------------------------------------------------------------
 122 // external accessors
 123 //-----------------------------------------------------------------------------
 124
 125 rtl::OUString ValueMemberNode::getNodeName() const
 126 {
 127     return m_node->info.getName();
 128 }
 129 //-----------------------------------------------------------------------------
 130
 131 node::Attributes ValueMemberNode::getAttributes()       const
 132 {
 133     return sharable::node(m_node)->getAttributes();
 134 }
 135 //-----------------------------------------------------------------------------
 136
 137
 138 bool ValueMemberNode::isDefault() const
 139 {
 140     if (hasChange())
 141         return m_xDeferredOperation->isToDefault();
 142
 143     return m_node->info.isDefault();
 144 }
 145 //-----------------------------------------------------------------------------
 146
 147 bool ValueMemberNode::canGetDefaultValue() const
 148 {
 149     return m_node->hasUsableDefault();
 150 }
 151 //-----------------------------------------------------------------------------
 152
 153 com::sun::star::uno::Any        ValueMemberNode::getValue() const
 154 {
 155     if (hasChange())
 156         return m_xDeferredOperation->getNewValue();
 157
 158     return m_node->getValue();
 159 }
 160 //-----------------------------------------------------------------------------
 161
 162 com::sun::star::uno::Any ValueMemberNode::getDefaultValue() const
 163 {
 164     return m_node->getDefaultValue();
 165 }
 166 //-----------------------------------------------------------------------------
 167
 168 com::sun::star::uno::Type       ValueMemberNode::getValueType() const
 169 {
 170     return m_node->getValueType();
 171 }
 172 //-----------------------------------------------------------------------------
 173
 174
 175 void ValueMemberUpdate::setValue(com::sun::star::uno::Any const& aNewValue)
 176 {
 177     if (m_aMemberNode.m_xDeferredOperation.is())
 178         m_aMemberNode.m_xDeferredOperation->setValue(aNewValue, m_aMemberNode.m_node);
 179     else
 180         setOriginalValue(m_aMemberNode.m_node, aNewValue );
 181 }
 182 //-----------------------------------------------------------------------------
 183
 184 void ValueMemberUpdate::setDefault()
 185 {
 186     if (m_aMemberNode.m_xDeferredOperation.is())
 187         m_aMemberNode.m_xDeferredOperation->setValueToDefault(m_aMemberNode.m_node);
 188     else
 189         setOriginalToDefault(m_aMemberNode.m_node);
 190 }
 191
 192 //-----------------------------------------------------------------------------
 193 // class ValueMemberNode::DeferredImpl
 194 //-----------------------------------------------------------------------------
 195
 196 ValueMemberNode::DeferredImpl::DeferredImpl(sharable::ValueNode * valueNode)
 197 : m_valueNode(valueNode)
 198 , m_aNewValue(valueNode->getValue())
 199 , m_bToDefault(false)
 200 , m_bChange(false)
 201 {}
 202 //-----------------------------------------------------------------------------
 203
 204 void ValueMemberNode::DeferredImpl::setValue(com::sun::star::uno::Any const& aNewValue, sharable::ValueNode * originalNode)
 205 {
 206     OSL_ENSURE(originalNode == m_valueNode, "Incorrect original node passed");
 207
 208     m_aNewValue = aNewValue;
 209     m_bToDefault = false;
 210
 211     m_bChange = originalNode->info.isDefault() || aNewValue != originalNode->getValue();
 212 }
 213 //-----------------------------------------------------------------------------
 214
 215 void ValueMemberNode::DeferredImpl::setValueToDefault(sharable::ValueNode * originalNode)
 216 {
 217     OSL_ENSURE(originalNode == m_valueNode, "Incorrect original node passed");
 218
 219     m_aNewValue = originalNode->getDefaultValue();
 220     m_bToDefault = true;
 221
 222     m_bChange = !originalNode->info.isDefault();
 223 }
 224 //-----------------------------------------------------------------------------
 225
 226 std::auto_ptr<ValueChange> ValueMemberNode::DeferredImpl::preCommitChange()
 227 {
 228     OSL_ENSURE(isChange(), "Trying to commit a non-change");
 229
 230     sharable::ValueNode * originalNode = getOriginalNode();
 231
 232     // first find the mode of the change
 233     ValueChange::Mode eMode;
 234
 235     if (m_bToDefault)
 236         eMode = ValueChange::setToDefault;
 237
 238     else if (! originalNode->info.isDefault())
 239         eMode = ValueChange::changeValue;
 240
 241     else
 242         eMode = ValueChange::wasDefault;
 243
 244     // now make a ValueChange
 245     std::auto_ptr<ValueChange>pChange( new ValueChange( originalNode->info.getName(),
 246                                                         sharable::node(originalNode)->getAttributes(),
 247                                                         eMode,
 248                                                         this->getNewValue(),
 249                                                         originalNode->getValue()
 250                                                       ) );
 251
 252     return  pChange;
 253 }
 254 //-----------------------------------------------------------------------------
 255
 256 void ValueMemberNode::DeferredImpl::finishCommit(ValueChange& rChange)
 257 {
 258     { (void)rChange; }
 259     OSL_ENSURE(rChange.getNewValue() == this->getNewValue(),"Committed change does not match the intended value");
 260
 261     sharable::ValueNode * originalNode = getOriginalNode();
 262
 263     m_aNewValue = originalNode->getValue();
 264     m_bToDefault = false;
 265
 266     OSL_ENSURE(rChange.getNewValue() == m_aNewValue,"Committed change does not match the actual value");
 267     m_bChange= false;
 268 }
 269 //-----------------------------------------------------------------------------
 270
 271 void ValueMemberNode::DeferredImpl::revertCommit(ValueChange& rChange)
 272 {
 273     { (void)rChange; }
 274
 275     OSL_ENSURE(rChange.getNewValue() == this->getNewValue(),"Reverted change does not match the intended value");
 276     OSL_ENSURE(isChange(), "ValueMemeberNode::DeferredImpl: No Changes to revert");
 277 }
 278 //-----------------------------------------------------------------------------
 279
 280 void ValueMemberNode::DeferredImpl::failedCommit(ValueChange&)
 281 {
 282     sharable::ValueNode * originalNode = getOriginalNode();
 283
 284     // discard the change
 285     m_aNewValue = originalNode->getValue();
 286     m_bToDefault = false;
 287
 288     m_bChange= false;
 289 }
 290 //-----------------------------------------------------------------------------
 291 ValueChangeImpl* ValueMemberNode::DeferredImpl::collectChange()
 292 {
 293     sharable::ValueNode * originalNode = getOriginalNode();
 294
 295     com::sun::star::uno::Any aOldValue = originalNode->getValue();
 296     if (!m_bChange)
 297     {
 298         return NULL;
 299     }
 300     else if (m_bToDefault)
 301     {
 302         OSL_ASSERT( m_aNewValue == originalNode->getDefaultValue() );
 303         return new ValueResetImpl( m_aNewValue, aOldValue );
 304     }
 305
 306     else
 307     {
 308         return new ValueReplaceImpl( m_aNewValue, aOldValue );
 309     }
 310 }
 311 //-----------------------------------------------------------------------------
 312
 313 ValueChangeImpl* ValueMemberNode::DeferredImpl::adjustToChange(ValueChange const& rExternalChange)
 314 {
 315     if (!m_bChange)
 316     {
 317         return NULL;
 318     }
 319     else if (m_bToDefault && rExternalChange.getMode() == ValueChange::changeDefault)
 320     {
 321         OSL_ASSERT( m_aNewValue == rExternalChange.getOldValue() );
 322
 323         m_aNewValue = rExternalChange.getNewValue();
 324
 325         return new ValueReplaceImpl(m_aNewValue, rExternalChange.getOldValue());
 326     }
 327     else // return Surrogate - does not honor m_bToDefault
 328     {
 329         return new ValueReplaceImpl(m_aNewValue, m_aNewValue);
 330     }
 331 }
 332 //-----------------------------------------------------------------------------
 333
 334 //-----------------------------------------------------------------------------
 335     }
 336 }