configmgr/source/backend/layerupdatemerger.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: layerupdatemerger.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 "layerupdatemerger.hxx"
  35 #include "layerupdatebuilder.hxx"
  36 #include "updatedata.hxx"
  37 // -----------------------------------------------------------------------------
  38
  39 namespace configmgr
  40 {
  41 // -----------------------------------------------------------------------------
  42     namespace backend
  43     {
  44 // -----------------------------------------------------------------------------
  45
  46 LayerUpdateMerger::LayerUpdateMerger(uno::Reference< backenduno::XLayer > const & _xSourceLayer, LayerUpdate const & _aLayerUpdate)
  47 : BasicUpdateMerger(_xSourceLayer)
  48 , m_aLayerUpdate(_aLayerUpdate)
  49 , m_xCurrentNode()
  50 {
  51 }
  52 // -----------------------------------------------------------------------------
  53
  54 LayerUpdateMerger::~LayerUpdateMerger()
  55 {
  56 }
  57 // -----------------------------------------------------------------------------
  58
  59 void LayerUpdateMerger::flushUpdate()
  60 {
  61     OSL_ENSURE(!BasicUpdateMerger::isHandling(), "LayerUpdateMerger: Unexpected: flushing data, while base implementation is active");
  62     OSL_ENSURE(m_xCurrentNode.is(),"LayerUpdateMerger: No data for flushing.");
  63
  64     if (m_xCurrentNode.is())
  65     {
  66         m_xCurrentNode->writeChildrenToLayer(getResultWriter().get());
  67         m_xCurrentNode.clear();
  68     }
  69 }
  70 // -----------------------------------------------------------------------------
  71
  72 void SAL_CALL LayerUpdateMerger::startLayer(  )
  73         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
  74 {
  75     BasicUpdateMerger::startLayer();
  76
  77     m_xCurrentNode = m_aLayerUpdate.getContextNode();
  78
  79     BasicUpdateMerger::findContext(m_aLayerUpdate.getContextPath());
  80 }
  81 // -----------------------------------------------------------------------------
  82
  83 void SAL_CALL LayerUpdateMerger::endLayer(  )
  84         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
  85 {
  86     BasicUpdateMerger::endLayer();
  87
  88     OSL_ENSURE(!m_xCurrentNode.is(), "Path being updated not found in data - update not written");
  89 }
  90 // -----------------------------------------------------------------------------
  91
  92 void SAL_CALL LayerUpdateMerger::overrideNode( const rtl::OUString& aName, sal_Int16 aAttributes, sal_Bool bClear )
  93         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
  94 {
  95     if (BasicUpdateMerger::isHandling())
  96     {
  97         BasicUpdateMerger::overrideNode(aName, aAttributes, bClear);
  98         return;
  99     }
 100
 101     OSL_ASSERT(m_xCurrentNode.is());
 102
 103     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getNodeByName(aName);
 104     if (!xUpdate.is())
 105     {
 106         BasicUpdateMerger::overrideNode(aName, aAttributes, bClear);
 107         OSL_ASSERT(BasicUpdateMerger::isHandling());
 108         return;
 109     }
 110     m_xCurrentNode->removeNodeByName(aName);
 111
 112     if (NodeUpdate * pNodeUpdate = xUpdate->asNodeUpdate(true))
 113     {
 114         getResultWriter()->overrideNode(aName, pNodeUpdate->updateFlags(aAttributes), bClear);
 115         m_xCurrentNode.set(pNodeUpdate);
 116     }
 117     else
 118     {
 119         xUpdate->writeToLayer(getResultWriter().get());
 120         BasicUpdateMerger::startSkipping();
 121     }
 122 }
 123 // -----------------------------------------------------------------------------
 124
 125 void SAL_CALL LayerUpdateMerger::addOrReplaceNode( const rtl::OUString& aName, sal_Int16 aAttributes )
 126         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 127 {
 128     if (BasicUpdateMerger::isHandling())
 129     {
 130         BasicUpdateMerger::addOrReplaceNode(aName, aAttributes);
 131         return;
 132     }
 133
 134     OSL_ASSERT(m_xCurrentNode.is());
 135
 136     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getNodeByName(aName);
 137     if (!xUpdate.is())
 138     {
 139         BasicUpdateMerger::addOrReplaceNode(aName, aAttributes);
 140         OSL_ASSERT(BasicUpdateMerger::isHandling());
 141         return;
 142     }
 143     m_xCurrentNode->removeNodeByName(aName);
 144
 145     if (NodeUpdate * pNodeUpdate = xUpdate->asNodeUpdate(true))
 146     {
 147         getResultWriter()->addOrReplaceNode(aName, pNodeUpdate->updateFlags(aAttributes));
 148         m_xCurrentNode.set(pNodeUpdate);
 149     }
 150     else
 151     {
 152         xUpdate->writeToLayer(getResultWriter().get());
 153         BasicUpdateMerger::startSkipping();
 154     }
 155 }
 156 // -----------------------------------------------------------------------------
 157
 158 void SAL_CALL LayerUpdateMerger::addOrReplaceNodeFromTemplate( const rtl::OUString& aName, const backenduno::TemplateIdentifier& aTemplate, sal_Int16 aAttributes )
 159         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 160 {
 161     if (BasicUpdateMerger::isHandling())
 162     {
 163         BasicUpdateMerger::addOrReplaceNodeFromTemplate(aName, aTemplate, aAttributes);
 164         return;
 165     }
 166
 167     OSL_ASSERT(m_xCurrentNode.is());
 168
 169     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getNodeByName(aName);
 170     if (!xUpdate.is())
 171     {
 172         BasicUpdateMerger::addOrReplaceNodeFromTemplate(aName, aTemplate, aAttributes);
 173         OSL_ASSERT(BasicUpdateMerger::isHandling());
 174         return;
 175     }
 176     m_xCurrentNode->removeNodeByName(aName);
 177
 178     if (NodeUpdate * pNodeUpdate = xUpdate->asNodeUpdate(true))
 179     {
 180         getResultWriter()->addOrReplaceNodeFromTemplate(aName, aTemplate, pNodeUpdate->updateFlags(aAttributes));
 181         m_xCurrentNode.set(pNodeUpdate);
 182     }
 183     else
 184     {
 185         xUpdate->writeToLayer(getResultWriter().get());
 186         BasicUpdateMerger::startSkipping();
 187     }
 188 }
 189 // -----------------------------------------------------------------------------
 190
 191 void SAL_CALL LayerUpdateMerger::endNode(  )
 192         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 193 {
 194     if (BasicUpdateMerger::isHandling())
 195     {
 196         BasicUpdateMerger::endNode();
 197         return;
 198     }
 199
 200     OSL_ASSERT(m_xCurrentNode.is());
 201
 202     // write unhandled so far changes
 203     m_xCurrentNode->writeChildrenToLayer( getResultWriter().get() );
 204
 205     rtl::Reference<NodeUpdate> xParent( m_xCurrentNode->getParent() );
 206
 207     if (xParent.is())
 208         getResultWriter()->endNode();
 209
 210     else
 211         BasicUpdateMerger::leaveContext();
 212
 213     m_xCurrentNode = xParent;
 214 }
 215 // -----------------------------------------------------------------------------
 216
 217 void SAL_CALL LayerUpdateMerger::dropNode( const rtl::OUString& aName )
 218         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 219 {
 220     if (BasicUpdateMerger::isHandling())
 221     {
 222         BasicUpdateMerger::dropNode(aName);
 223         return;
 224     }
 225
 226     OSL_ASSERT(m_xCurrentNode.is());
 227
 228     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getNodeByName(aName);
 229     if (xUpdate.is())
 230     {
 231         m_xCurrentNode->removeNodeByName(aName);
 232
 233         if (NodeUpdate * pNodeUpdate = xUpdate->asNodeUpdate())
 234         {
 235             if (pNodeUpdate-> getOperation() == NodeUpdate::replace)
 236             {
 237                 xUpdate->writeToLayer( getResultWriter().get() );
 238                 return;
 239             }
 240             else
 241             {
 242                 malformedUpdate("LayerUpdateMerger: Applying modification to dropped node");
 243             }
 244         }
 245     }
 246
 247     getResultWriter()->dropNode(aName);
 248 }
 249 // -----------------------------------------------------------------------------
 250
 251 void SAL_CALL LayerUpdateMerger::overrideProperty( const rtl::OUString& aName, sal_Int16 aAttributes, const uno::Type& aType, sal_Bool bClear )
 252         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 253 {
 254     if (BasicUpdateMerger::isHandling())
 255     {
 256         BasicUpdateMerger::overrideProperty(aName, aAttributes, aType, bClear);
 257         return;
 258     }
 259
 260     OSL_ASSERT( m_xCurrentNode.is());
 261
 262     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getPropertyByName(aName);
 263     if (!xUpdate.is())
 264     {
 265         BasicUpdateMerger::overrideProperty(aName, aAttributes, aType, bClear);
 266         OSL_ASSERT(BasicUpdateMerger::isHandling());
 267         return;
 268     }
 269
 270     m_xCurrentNode->removePropertyByName(aName);
 271
 272     if (PropertyUpdate * pPropUpdate = xUpdate->asPropertyUpdate())
 273     {
 274         OSL_ENSURE( aType == pPropUpdate->getValueType() ||
 275                     aType == uno::Type()                 ||
 276                     pPropUpdate->getValueType() == uno::Type(),
 277                     "Error in update merger: type mismatch overriding property ...");
 278
 279         getResultWriter()->overrideProperty(aName, pPropUpdate->updateFlags(aAttributes), aType, bClear);
 280         m_xCurrentProp.set(pPropUpdate);
 281     }
 282     else
 283     {
 284         xUpdate->writeToLayer(getResultWriter().get());
 285         BasicUpdateMerger::startSkipping();
 286     }
 287 }
 288 // -----------------------------------------------------------------------------
 289
 290 void SAL_CALL LayerUpdateMerger::endProperty(  )
 291         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 292 {
 293     if (BasicUpdateMerger::isHandling())
 294     {
 295         BasicUpdateMerger::endProperty();
 296         return;
 297     }
 298
 299     OSL_ASSERT(m_xCurrentNode.is());
 300
 301     if (!m_xCurrentProp.is())
 302     {
 303         rtl::OUString sMsg( RTL_CONSTASCII_USTRINGPARAM("LayerUpdateMerger: Invalid data: Ending property that wasn't started.") );
 304         throw backenduno::MalformedDataException( sMsg, *this, uno::Any() );
 305     }
 306
 307     // write unhandled so far values
 308     m_xCurrentProp->writeValuesToLayer( getResultWriter().get() );
 309
 310     getResultWriter()->endProperty();
 311
 312     m_xCurrentProp.clear();
 313 }
 314 // -----------------------------------------------------------------------------
 315
 316 void SAL_CALL LayerUpdateMerger::setPropertyValue( const uno::Any& aValue )
 317         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 318 {
 319     if (BasicUpdateMerger::isHandling())
 320     {
 321         BasicUpdateMerger::setPropertyValue(aValue);
 322         return;
 323     }
 324
 325     OSL_ASSERT(m_xCurrentNode.is());
 326
 327     if (!m_xCurrentProp.is())
 328     {
 329         rtl::OUString sMsg( RTL_CONSTASCII_USTRINGPARAM("LayerUpdateMerger: Invalid data: setting value, but no property is started.") );
 330         throw backenduno::MalformedDataException( sMsg, *this, uno::Any() );
 331     }
 332
 333     if (!m_xCurrentProp->hasChange())
 334     {
 335         BasicUpdateMerger::setPropertyValue(aValue);
 336         return;
 337     }
 338
 339 #ifndef CFG_UPDATEMERGER_BATCHWRITE_PROPERTIES
 340     if (m_xCurrentProp->hasValue())
 341     {
 342         getResultWriter()->setPropertyValue(m_xCurrentProp->getValue());
 343     }
 344     else
 345     {
 346         OSL_ENSURE(m_xCurrentProp->hasReset(),"LayerUpdateMerger: ERROR: Unknown change type in PropertyUpdate");
 347         // write nothing to result
 348     }
 349
 350     // mark handled
 351     m_xCurrentProp->removeValue();
 352 #endif
 353 }
 354 // -----------------------------------------------------------------------------
 355
 356 void SAL_CALL LayerUpdateMerger::setPropertyValueForLocale( const uno::Any& aValue, const rtl::OUString & aLocale )
 357         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 358 {
 359     if (BasicUpdateMerger::isHandling())
 360     {
 361         BasicUpdateMerger::setPropertyValueForLocale(aValue, aLocale);
 362         return;
 363     }
 364
 365     OSL_ASSERT(m_xCurrentNode.is());
 366
 367     if (!m_xCurrentProp.is())
 368     {
 369         rtl::OUString sMsg( RTL_CONSTASCII_USTRINGPARAM("LayerUpdateMerger: Invalid data: setting value, but no property is started.") );
 370         throw backenduno::MalformedDataException( sMsg, *this, uno::Any() );
 371     }
 372
 373     if (!m_xCurrentProp->hasChangeFor(aLocale))
 374     {
 375         BasicUpdateMerger::setPropertyValueForLocale(aValue, aLocale);
 376         return;
 377     }
 378
 379 #ifndef CFG_UPDATEMERGER_BATCHWRITE_PROPERTIES
 380     if (m_xCurrentProp->hasValueFor(aLocale))
 381     {
 382         getResultWriter()->setPropertyValueForLocale(m_xCurrentProp->getValueFor(aLocale),aLocale);
 383     }
 384     else
 385     {
 386         OSL_ENSURE(m_xCurrentProp->hasResetFor(aLocale),"LayerUpdateMerger: ERROR: Unknown change type in PropertyUpdate");
 387         // write nothing to result
 388     }
 389
 390     // mark handled
 391     m_xCurrentProp->removeValueFor(aLocale);
 392 #endif
 393 }
 394 // -----------------------------------------------------------------------------
 395
 396 void SAL_CALL LayerUpdateMerger::addProperty( const rtl::OUString& aName, sal_Int16 aAttributes, const uno::Type& aType )
 397         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 398 {
 399     if (BasicUpdateMerger::isHandling())
 400     {
 401         BasicUpdateMerger::addProperty(aName, aAttributes, aType);
 402         return;
 403     }
 404     OSL_ASSERT( m_xCurrentNode.is());
 405
 406     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getPropertyByName(aName);
 407     if (!xUpdate.is())
 408     {
 409         BasicUpdateMerger::addProperty(aName, aAttributes, aType);
 410         return;
 411     }
 412
 413     m_xCurrentNode->removePropertyByName(aName);
 414
 415     if (PropertyUpdate * pPropUpdate = xUpdate->asPropertyUpdate())
 416     {
 417         if (pPropUpdate->hasValue() && pPropUpdate->getValue().hasValue())
 418         {
 419             // TODO: validate value-type
 420             uno::Any aNewValue = pPropUpdate->getValue();
 421             OSL_ASSERT( aNewValue.hasValue() );
 422
 423             if (aNewValue.getValueType() != aType)
 424                 malformedUpdate("LayerUpdateMerger: cannot do type conversion while writing updates");
 425
 426             getResultWriter()->addPropertyWithValue(aName, pPropUpdate->updateFlags(aAttributes), aNewValue);
 427         }
 428         else
 429         {
 430             // TODO: validate type
 431             if (pPropUpdate->getValueType() != aType && pPropUpdate->getValueType() != uno::Type())
 432                 malformedUpdate("LayerUpdateMerger: types for property update do not match");
 433
 434             OSL_ENSURE(!pPropUpdate->hasReset(),"Warning: resetting the value of an added property is undefined - reverting to NULL");
 435             getResultWriter()->addProperty(aName, pPropUpdate->updateFlags(aAttributes), aType);
 436         }
 437     }
 438     else
 439     {
 440         xUpdate->writeToLayer(getResultWriter().get());
 441     }
 442 }
 443 // -----------------------------------------------------------------------------
 444
 445 void SAL_CALL LayerUpdateMerger::addPropertyWithValue( const rtl::OUString& aName, sal_Int16 aAttributes, const uno::Any& aValue )
 446         throw (backenduno::MalformedDataException, lang::WrappedTargetException, uno::RuntimeException)
 447 {
 448     if (BasicUpdateMerger::isHandling())
 449     {
 450         BasicUpdateMerger::addPropertyWithValue(aName, aAttributes, aValue);
 451         return;
 452     }
 453     OSL_ASSERT( m_xCurrentNode.is());
 454
 455     rtl::Reference<ElementUpdate> xUpdate = m_xCurrentNode->getPropertyByName(aName);
 456     if (!xUpdate.is())
 457     {
 458         BasicUpdateMerger::addPropertyWithValue(aName, aAttributes, aValue);
 459         return;
 460     }
 461
 462     m_xCurrentNode->removePropertyByName(aName);
 463
 464     if (PropertyUpdate * pPropUpdate = xUpdate->asPropertyUpdate())
 465     {
 466         if (!pPropUpdate->hasChange()) // attribute change only
 467         {
 468             getResultWriter()->addPropertyWithValue(aName, pPropUpdate->updateFlags(aAttributes), aValue);
 469         }
 470         else if (pPropUpdate->hasReset())
 471         {
 472             // write nothing
 473         }
 474         else if (pPropUpdate->getValue().hasValue()) // setting to non-NULL value
 475         {
 476             OSL_ASSERT(pPropUpdate->hasValue());
 477
 478             // TODO: validate value-type
 479             uno::Any aNewValue = pPropUpdate->getValue();
 480
 481             if (aNewValue.getValueType() != aValue.getValueType())
 482                 malformedUpdate("LayerUpdateMerger: cannot do type conversion while writing updates");
 483
 484             getResultWriter()->addPropertyWithValue(aName, pPropUpdate->updateFlags(aAttributes), aNewValue);
 485         }
 486         else // setting to null value
 487         {
 488             OSL_ASSERT(pPropUpdate->hasValue());
 489
 490             // TODO: validate type
 491             if (pPropUpdate->getValueType() != aValue.getValueType() && pPropUpdate->getValueType() != uno::Type())
 492                 malformedUpdate("LayerUpdateMerger: types for property update do not match");
 493
 494             getResultWriter()->addProperty(aName, pPropUpdate->updateFlags(aAttributes), aValue.getValueType());
 495         }
 496     }
 497     else
 498     {
 499         xUpdate->writeToLayer(getResultWriter().get());
 500     }
 501 }
 502 // -----------------------------------------------------------------------------
 503
 504 void LayerUpdateMerger::malformedUpdate(sal_Char const * pMsg)
 505 {
 506     { (void)pMsg; }
 507     OSL_ENSURE(false,pMsg);
 508 }
 509 // -----------------------------------------------------------------------------
 510 // -----------------------------------------------------------------------------
 511     } // namespace
 512
 513 // -----------------------------------------------------------------------------
 514 } // namespace
 515