configmgr/source/treecache/cacheline.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: cacheline.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
  34 #include "cacheline.hxx"
  35 #include "builddata.hxx"
  36 #include "treechangefactory.hxx"
  37 #include "mergechange.hxx"
  38 #include "configexcept.hxx"
  39 #include "tracer.hxx"
  40 #include <osl/diagnose.h>
  41
  42 namespace configmgr
  43 {
  44 // -----------------------------------------------------------------------------
  45     static inline rtl::OUString implExtractModuleName(configuration::AbsolutePath const& _aConfigPath)
  46     {
  47         return _aConfigPath.getModuleName();
  48     }
  49
  50
  51 // -----------------------------------------------------------------------------
  52 // class CacheLine
  53 // -----------------------------------------------------------------------------
  54
  55 // -----------------------------------------------------------------------------
  56
  57     CacheLine::CacheLine(rtl::OUString const & _aModuleName)
  58     : m_base(NULL)
  59     , m_name(_aModuleName)
  60     , m_nDataRefs(0)
  61     {
  62     }
  63 // -----------------------------------------------------------------------------
  64
  65     CacheLine::CacheLine(rtl::OUString const & _aModuleName, sharable::TreeFragment * _pSegment)
  66     : m_base(_pSegment)
  67     , m_name(_aModuleName)
  68     , m_nDataRefs(0)
  69     {
  70     }
  71
  72 // -----------------------------------------------------------------------------
  73
  74     void CacheLine::setBase(sharable::TreeFragment * _base)
  75     {
  76         OSL_PRECOND(m_base == NULL, "CacheLine: Data base address was already set");
  77         OSL_PRECOND( _base != NULL, "CacheLine: Cannot set NULL base address");
  78         m_base = _base;
  79     }
  80 // -----------------------------------------------------------------------------
  81
  82     rtl::Reference<CacheLine> CacheLine::createAttached( rtl::OUString const & _aModuleName,
  83                                             sharable::TreeFragment * _aSegment
  84                                           ) SAL_THROW((com::sun::star::uno::RuntimeException))
  85     {
  86         if (_aModuleName.getLength() == 0)
  87         {
  88             OSL_ENSURE(false, "Cannot make a cache line without a name");
  89             return NULL;
  90         }
  91         if (_aSegment == NULL)
  92         {
  93             OSL_ENSURE(false, "Cannot attach a cache line to a NULL segment");
  94             return NULL;
  95         }
  96
  97         rtl::Reference<CacheLine> xResult = new CacheLine(_aModuleName,_aSegment);
  98
  99         return xResult;
 100     }
 101 // -----------------------------------------------------------------------------
 102
 103     rtl::Reference<CacheLine> CacheLine::createNew( rtl::OUString const & _aModuleName
 104                                       ) SAL_THROW((com::sun::star::uno::RuntimeException))
 105     {
 106         if (_aModuleName.getLength() == 0)
 107         {
 108             OSL_ENSURE(false, "Cannot make a cache line without a name");
 109             return NULL;
 110         }
 111
 112         rtl::Reference<CacheLine> xResult = new CacheLine(_aModuleName);
 113
 114         return xResult;
 115     }
 116 // -------------------------------------------------------------------------
 117
 118     rtl::OUString CacheLine::getModuleName() const
 119     {
 120         return m_name;
 121     }
 122 // -----------------------------------------------------------------------------
 123
 124     sharable::TreeFragment * CacheLine::getPartialTree(configuration::AbsolutePath const& aConfigName) const
 125     {
 126         sharable::Node * parent = internalGetNode(aConfigName.getParentPath());
 127
 128         if (parent != 0 && parent->isSet())
 129             return parent->set.getElement(aConfigName.getLocalName().getName());
 130         else
 131             return NULL;
 132     }
 133 // -----------------------------------------------------------------------------
 134
 135     bool CacheLine::hasDefaults() const
 136     {
 137         return m_base != 0 && m_base->hasDefaultsAvailable();
 138     }
 139 // -----------------------------------------------------------------------------
 140     sharable::Node * CacheLine::internalGetNode(configuration::AbsolutePath const& aConfigName) const
 141     {
 142         OSL_ASSERT(m_base != 0);
 143         sharable::Node * node = m_base->getRootNode();
 144         OSL_ASSERT(node != 0);
 145         std::vector< configuration::Path::Component >::const_reverse_iterator i(
 146             aConfigName.begin());
 147         OSL_ASSERT(
 148             i != aConfigName.end() && node->getName() == i->getInternalName());
 149         while (node != 0 && ++i != aConfigName.end()) {
 150             node = node->getSubnode(i->getName());
 151         }
 152         return node;
 153     }
 154 // -----------------------------------------------------------------------------
 155
 156     sharable::Node * CacheLine::getNode(configuration::AbsolutePath const& aConfigName) const
 157     {
 158         return internalGetNode(aConfigName);
 159     }
 160 // -------------------------------------------------------------------------
 161
 162     sharable::TreeFragment * CacheLine::setComponentData( backend::ComponentDataStruct const & _aComponentInstance,
 163                                                    bool _bWithDefaults
 164                                                    ) SAL_THROW((com::sun::star::uno::RuntimeException))
 165     {
 166         OSL_PRECOND(_aComponentInstance.data.get(), "CacheLine::insertDefaults: inserting NULL defaults !");
 167         OSL_PRECOND(_aComponentInstance.name == this->getModuleName(),"Data location does not match module");
 168
 169         OSL_PRECOND(base() == NULL, "Data is already loaded");
 170
 171         if (base() == NULL) // no data yet
 172         {
 173             this->setBase( data::buildTree(_aComponentInstance.data->getName(), *_aComponentInstance.data, _bWithDefaults) );
 174         }
 175
 176         return this->base();
 177     }
 178 // -----------------------------------------------------------------------------
 179
 180     sharable::TreeFragment * CacheLine::insertDefaults( backend::NodeInstance const & _aDefaultInstance
 181                                                ) SAL_THROW((com::sun::star::uno::RuntimeException))
 182     {
 183         OSL_PRECOND(_aDefaultInstance.data().get(), "CacheLine::insertDefaults: inserting NULL defaults !");
 184         OSL_PRECOND(_aDefaultInstance.root().getDepth() == 1, "Should have complete component to fill tree with defaults");
 185         OSL_PRECOND(_aDefaultInstance.root().getModuleName() == this->getModuleName(),"Data location does not match module");
 186
 187         OSL_PRECOND(m_base != NULL, "Data must already be loaded to insert defaults");
 188
 189         if (m_base != NULL)
 190         {
 191             data::mergeDefaults(m_base,*_aDefaultInstance.data());
 192         }
 193
 194         return m_base;
 195     }
 196 // -----------------------------------------------------------------------------
 197 // -----------------------------------------------------------------------------
 198
 199     ExtendedCacheLine::ExtendedCacheLine(rtl::OUString const & _aModuleName)
 200     : CacheLine(_aModuleName)
 201     , m_pPending()
 202     {
 203     }
 204
 205 // -----------------------------------------------------------------------------
 206
 207     ExtendedCacheLine::ExtendedCacheLine(rtl::OUString const & _aModuleName,
 208                                          sharable::TreeFragment * _aSegment)
 209     : CacheLine(_aModuleName,_aSegment)
 210     , m_pPending()
 211     {
 212     }
 213
 214 // -----------------------------------------------------------------------------
 215
 216     rtl::Reference<ExtendedCacheLine> ExtendedCacheLine::createAttached( rtl::OUString const & _aModuleName,
 217                                                             sharable::TreeFragment * _aSegment
 218                                                           ) SAL_THROW((com::sun::star::uno::RuntimeException))
 219     {
 220         if (_aModuleName.getLength() == 0)
 221         {
 222             OSL_ENSURE(false, "Cannot make a cache line without a name");
 223             return NULL;
 224         }
 225         if (_aSegment == NULL)
 226         {
 227             OSL_ENSURE(false, "Cannot attach a cache line to a NULL segment");
 228             return NULL;
 229         }
 230
 231         rtl::Reference<ExtendedCacheLine> xResult = new ExtendedCacheLine(_aModuleName,_aSegment);
 232
 233         return xResult;
 234     }
 235 // -----------------------------------------------------------------------------
 236
 237     rtl::Reference<ExtendedCacheLine> ExtendedCacheLine::createNew( rtl::OUString const & _aModuleName
 238                                                       ) SAL_THROW((com::sun::star::uno::RuntimeException))
 239     {
 240         if (_aModuleName.getLength() == 0)
 241         {
 242             OSL_ENSURE(false, "Cannot make a cache line without a name");
 243             return NULL;
 244         }
 245
 246         rtl::Reference<ExtendedCacheLine> xResult = new ExtendedCacheLine(_aModuleName);
 247
 248         return xResult;
 249     }
 250 // -------------------------------------------------------------------------
 251
 252     void ExtendedCacheLine::addPending(backend::ConstUpdateInstance const & _anUpdate) SAL_THROW((com::sun::star::uno::RuntimeException))
 253     {
 254         configuration::AbsolutePath aRootLocation = _anUpdate.root();
 255
 256         OSL_PRECOND(!aRootLocation.isRoot(),"Pending change cannot be located at root");
 257         OSL_PRECOND(aRootLocation.getModuleName() == this->getModuleName(),"Pending change location does not match module");
 258
 259         OSL_PRECOND(_anUpdate.data() != NULL,"Adding NULL 'pending' change");
 260         OSL_PRECOND(_anUpdate.data()->getNodeName() == aRootLocation.getLocalName().getName(),
 261                     "Path to pending change does not match change name");
 262
 263         using std::auto_ptr;
 264
 265         // first make the _pSubtreeChange a full tree starting at the module root
 266         auto_ptr<SubtreeChange> pRootChange;
 267         SubtreeChange *pExistingEntry = NULL;
 268
 269         std::vector<configuration::Path::Component>::const_reverse_iterator last = aRootLocation.end();
 270
 271         OSL_ASSERT(last != aRootLocation.begin());
 272         --last;
 273
 274         for (std::vector<configuration::Path::Component>::const_reverse_iterator it = aRootLocation.begin();
 275              it != last;
 276              ++it)
 277         {
 278             OSL_ASSERT( it   != aRootLocation.end());
 279             OSL_ASSERT( it+1 != aRootLocation.end());
 280             // We need to create a new SubtreeChange
 281             rtl::OUString const aChangeName      = it->getName();
 282             rtl::OUString const aElementTypeName = (it+1)->getTypeName();
 283
 284             auto_ptr<SubtreeChange> pNewChange =
 285                         OTreeChangeFactory::createDummyChange(aChangeName, aElementTypeName);
 286
 287             if (pExistingEntry == NULL)
 288             {
 289                 OSL_ASSERT(pRootChange.get() == NULL);
 290
 291                 pRootChange     = pNewChange;
 292                 pExistingEntry  = pRootChange.get();
 293             }
 294             else
 295             {
 296                 OSL_ASSERT(pRootChange.get() != NULL);
 297
 298                 pExistingEntry->addChange(base_ptr(pNewChange));
 299
 300                 Change* pChange = pExistingEntry->getChange(aChangeName);
 301                 pExistingEntry = static_cast<SubtreeChange*>(pChange);
 302
 303                 OSL_ENSURE(dynamic_cast< SubtreeChange * >(pChange) != 0, "ERROR: Cannot recover change just added");
 304             }
 305         }
 306
 307         auto_ptr<SubtreeChange> pAddedChange( new SubtreeChange(*_anUpdate.data(), treeop::DeepChildCopy()) );
 308
 309         if (aRootLocation.getDepth() > 1)
 310         {
 311             OSL_ASSERT(pRootChange.get() != NULL && pExistingEntry != NULL);
 312
 313             // the _pSubtreeChange did not start at root, so add its clone to the built dummies
 314             pExistingEntry->addChange(base_ptr(pAddedChange));
 315         }
 316         else
 317         {
 318             OSL_ASSERT(pRootChange.get() == NULL && pExistingEntry == NULL);
 319
 320             // the _pSubtreeChange starts at root, so just reset pRootChange
 321             pRootChange = pAddedChange;
 322         }
 323         OSL_ASSERT(pRootChange.get() != NULL);
 324
 325         if (m_pPending.get() == NULL)
 326         {
 327             // no merge is need, because the existing pending changes are empty
 328             m_pPending = pRootChange;
 329         }
 330         else
 331         {
 332             try
 333             {
 334                 // We need to merge the new rebased changes into the m_pPending
 335                 combineUpdates(*pRootChange,*m_pPending);
 336             }
 337             catch (configuration::Exception& e)
 338             {
 339                 rtl::OUString sMessage(RTL_CONSTASCII_USTRINGPARAM("Update cache for module: Could not add pending changes at"));
 340
 341                 sMessage += aRootLocation.toString();
 342
 343                 sMessage += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(". Internal Exception:")) + e.message();
 344
 345                 throw uno::RuntimeException(sMessage,0);
 346             }
 347         }
 348
 349         OSL_POSTCOND(m_pPending.get() != NULL, "Could not insert new pending changes");
 350     }
 351 // -----------------------------------------------------------------------------
 352
 353
 354 } // namespace configmgr
 355
 356