67f88d1418
2008/04/01 15:06:54 thb 1.10.16.3: #i85898# Stripping all external header guards 2008/04/01 12:27:34 thb 1.10.16.2: #i85898# Stripping all external header guards 2008/03/31 12:22:53 rt 1.10.16.1: #i87441# Change license header to LPGL v3.
372 lines
13 KiB
C++
372 lines
13 KiB
C++
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2008 by Sun Microsystems, Inc.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: cacheline.cxx,v $
|
|
* $Revision: 1.11 $
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_configmgr.hxx"
|
|
|
|
#include "cacheline.hxx"
|
|
#include "setnodeaccess.hxx"
|
|
#include "treeaccessor.hxx"
|
|
#include "builddata.hxx"
|
|
#include "treechangefactory.hxx"
|
|
#include "mergechange.hxx"
|
|
#include "configexcept.hxx"
|
|
#include "tracer.hxx"
|
|
#include <osl/diagnose.h>
|
|
|
|
namespace configmgr
|
|
{
|
|
// -----------------------------------------------------------------------------
|
|
static inline CacheLine::Name implExtractModuleName(CacheLine::Path const& _aConfigPath)
|
|
{
|
|
return _aConfigPath.getModuleName();
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// class CacheLine
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
CacheLine::CacheLine(Name const & _aModuleName)
|
|
: m_base(NULL)
|
|
, m_name(_aModuleName)
|
|
, m_nDataRefs(0)
|
|
{
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
CacheLine::CacheLine(Name const & _aModuleName, data::TreeAddress _pSegment)
|
|
: m_base(_pSegment)
|
|
, m_name(_aModuleName)
|
|
, m_nDataRefs(0)
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void CacheLine::setBase(data::TreeAddress _base)
|
|
{
|
|
OSL_PRECOND(m_base == NULL, "CacheLine: Data base address was already set");
|
|
OSL_PRECOND( _base != NULL, "CacheLine: Cannot set NULL base address");
|
|
m_base = _base;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
CacheLineRef CacheLine::createAttached( Name const & _aModuleName,
|
|
data::TreeAddress _aSegment
|
|
) CFG_UNO_THROW_RTE( )
|
|
{
|
|
if (_aModuleName.isEmpty())
|
|
{
|
|
OSL_ENSURE(false, "Cannot make a cache line without a name");
|
|
return NULL;
|
|
}
|
|
if (_aSegment == NULL)
|
|
{
|
|
OSL_ENSURE(false, "Cannot attach a cache line to a NULL segment");
|
|
return NULL;
|
|
}
|
|
|
|
CacheLineRef xResult = new CacheLine(_aModuleName,_aSegment);
|
|
|
|
return xResult;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
CacheLineRef CacheLine::createNew( Name const & _aModuleName
|
|
) CFG_UNO_THROW_RTE( )
|
|
{
|
|
if (_aModuleName.isEmpty())
|
|
{
|
|
OSL_ENSURE(false, "Cannot make a cache line without a name");
|
|
return NULL;
|
|
}
|
|
|
|
CacheLineRef xResult = new CacheLine(_aModuleName);
|
|
|
|
return xResult;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
|
|
CacheLine::Name CacheLine::getModuleName() const
|
|
{
|
|
return m_name;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
data::TreeAddress CacheLine::getPartialTree(Path const& aConfigName) const
|
|
{
|
|
data::SetNodeAccess aParentSet( internalGetNode(aConfigName.getParentPath()) );
|
|
|
|
if (aParentSet.isValid())
|
|
return aParentSet.getElementTree(aConfigName.getLocalName().getName());
|
|
else
|
|
return NULL;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
bool CacheLine::hasDefaults() const
|
|
{
|
|
if ( m_base != NULL ) return false; // cannot get defaults without data
|
|
|
|
data::TreeAccessor aModuleTree(m_base);
|
|
OSL_ASSERT( aModuleTree != NULL);
|
|
|
|
return aModuleTree->hasDefaultsAvailable();
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
data::NodeAccess CacheLine::internalGetNode(Path const& aConfigName) const
|
|
{
|
|
OSL_ENSURE( m_base != NULL, "Cannot get a node from a dataless module");
|
|
|
|
data::TreeAccessor aModuleTree(m_base);
|
|
OSL_ASSERT(aModuleTree != NULL);
|
|
|
|
data::NodeAccess aNode = aModuleTree.getRootNode();
|
|
OSL_ENSURE( aNode.isValid(), "CacheLine contains no nodes");
|
|
|
|
Path::Iterator it = aConfigName.begin();
|
|
OSL_ENSURE( it != aConfigName.end(), "Empty Path can't match any module");
|
|
OSL_ENSURE( aNode.isValid() && aNode.getName() == it->getInternalName(), "Module part in config path does not match selected CacheLine");
|
|
|
|
// find child of node
|
|
// might be done using a visitor
|
|
while(aNode.isValid() && ++it != aConfigName.end())
|
|
{
|
|
aNode = data::getSubnode(aNode,it->getName());
|
|
}
|
|
return aNode;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
data::NodeAddress CacheLine::getNode(Path const& aConfigName) const
|
|
{
|
|
data::NodeAccess aNode = internalGetNode(aConfigName);
|
|
return aNode;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
|
|
data::TreeAddress CacheLine::setComponentData( backend::ComponentData const & _aComponentInstance,
|
|
bool _bWithDefaults
|
|
) CFG_UNO_THROW_RTE( )
|
|
{
|
|
OSL_PRECOND(_aComponentInstance.data.get(), "CacheLine::insertDefaults: inserting NULL defaults !");
|
|
OSL_PRECOND(_aComponentInstance.name == this->getModuleName(),"Data location does not match module");
|
|
|
|
OSL_PRECOND(base() == NULL, "Data is already loaded");
|
|
|
|
if (base() == NULL) // no data yet
|
|
{
|
|
this->setBase( data::buildTree(_aComponentInstance.data->getName(), *_aComponentInstance.data, _bWithDefaults) );
|
|
}
|
|
|
|
return this->base();
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
data::TreeAddress CacheLine::insertDefaults( backend::NodeInstance const & _aDefaultInstance
|
|
) CFG_UNO_THROW_RTE( )
|
|
{
|
|
OSL_PRECOND(_aDefaultInstance.data().get(), "CacheLine::insertDefaults: inserting NULL defaults !");
|
|
OSL_PRECOND(_aDefaultInstance.root().isModuleRoot(), "Should have complete component to fill tree with defaults");
|
|
OSL_PRECOND(_aDefaultInstance.root().getModuleName() == this->getModuleName(),"Data location does not match module");
|
|
|
|
OSL_PRECOND(m_base != NULL, "Data must already be loaded to insert defaults");
|
|
|
|
if (m_base != NULL)
|
|
{
|
|
data::mergeDefaults(m_base,*_aDefaultInstance.data());
|
|
}
|
|
|
|
return m_base;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------------
|
|
|
|
ExtendedCacheLine::ExtendedCacheLine(Name const & _aModuleName)
|
|
: CacheLine(_aModuleName)
|
|
, m_pPending()
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
ExtendedCacheLine::ExtendedCacheLine(Name const & _aModuleName,
|
|
data::TreeAddress _aSegment)
|
|
: CacheLine(_aModuleName,_aSegment)
|
|
, m_pPending()
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
ExtendedCacheLineRef ExtendedCacheLine::createAttached( Name const & _aModuleName,
|
|
data::TreeAddress _aSegment
|
|
) CFG_UNO_THROW_RTE( )
|
|
{
|
|
if (_aModuleName.isEmpty())
|
|
{
|
|
OSL_ENSURE(false, "Cannot make a cache line without a name");
|
|
return NULL;
|
|
}
|
|
if (_aSegment == NULL)
|
|
{
|
|
OSL_ENSURE(false, "Cannot attach a cache line to a NULL segment");
|
|
return NULL;
|
|
}
|
|
|
|
ExtendedCacheLineRef xResult = new ExtendedCacheLine(_aModuleName,_aSegment);
|
|
|
|
return xResult;
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
ExtendedCacheLineRef ExtendedCacheLine::createNew( Name const & _aModuleName
|
|
) CFG_UNO_THROW_RTE( )
|
|
{
|
|
if (_aModuleName.isEmpty())
|
|
{
|
|
OSL_ENSURE(false, "Cannot make a cache line without a name");
|
|
return NULL;
|
|
}
|
|
|
|
ExtendedCacheLineRef xResult = new ExtendedCacheLine(_aModuleName);
|
|
|
|
return xResult;
|
|
}
|
|
// -------------------------------------------------------------------------
|
|
|
|
void ExtendedCacheLine::addPending(backend::ConstUpdateInstance const & _anUpdate) CFG_UNO_THROW_RTE( )
|
|
{
|
|
Path aRootLocation = _anUpdate.root().location();
|
|
|
|
OSL_PRECOND(!aRootLocation.isRoot(),"Pending change cannot be located at root");
|
|
OSL_PRECOND(aRootLocation.getModuleName() == this->getModuleName(),"Pending change location does not match module");
|
|
|
|
OSL_PRECOND(_anUpdate.data() != NULL,"Adding NULL 'pending' change");
|
|
OSL_PRECOND(_anUpdate.data()->getNodeName() == aRootLocation.getLocalName().getName().toString(),
|
|
"Path to pending change does not match change name");
|
|
|
|
using std::auto_ptr;
|
|
|
|
// first make the _pSubtreeChange a full tree starting at the module root
|
|
auto_ptr<SubtreeChange> pRootChange;
|
|
SubtreeChange *pExistingEntry = NULL;
|
|
|
|
Path::Iterator last = aRootLocation.end();
|
|
|
|
OSL_ASSERT(last != aRootLocation.begin());
|
|
--last;
|
|
|
|
for (Path::Iterator it = aRootLocation.begin();
|
|
it != last;
|
|
++it)
|
|
{
|
|
OSL_ASSERT( it != aRootLocation.end());
|
|
OSL_ASSERT( it+1 != aRootLocation.end());
|
|
// We need to create a new SubtreeChange
|
|
Name const aChangeName = it->getName();
|
|
Name const aElementTypeName = (it+1)->getTypeName();
|
|
|
|
auto_ptr<SubtreeChange> pNewChange =
|
|
OTreeChangeFactory::createDummyChange(aChangeName, aElementTypeName);
|
|
|
|
if (pExistingEntry == NULL)
|
|
{
|
|
OSL_ASSERT(pRootChange.get() == NULL);
|
|
|
|
pRootChange = pNewChange;
|
|
pExistingEntry = pRootChange.get();
|
|
}
|
|
else
|
|
{
|
|
OSL_ASSERT(pRootChange.get() != NULL);
|
|
|
|
pExistingEntry->addChange(base_ptr(pNewChange));
|
|
|
|
Change* pChange = pExistingEntry->getChange(aChangeName.toString());
|
|
pExistingEntry = static_cast<SubtreeChange*>(pChange);
|
|
|
|
OSL_ENSURE(pChange && pChange->ISA(SubtreeChange), "ERROR: Cannot recover change just added");
|
|
}
|
|
}
|
|
|
|
auto_ptr<SubtreeChange> pAddedChange( new SubtreeChange(*_anUpdate.data(), SubtreeChange::DeepChildCopy()) );
|
|
|
|
if (aRootLocation.getDepth() > 1)
|
|
{
|
|
OSL_ASSERT(pRootChange.get() != NULL && pExistingEntry != NULL);
|
|
|
|
// the _pSubtreeChange did not start at root, so add its clone to the built dummies
|
|
pExistingEntry->addChange(base_ptr(pAddedChange));
|
|
}
|
|
else
|
|
{
|
|
OSL_ASSERT(pRootChange.get() == NULL && pExistingEntry == NULL);
|
|
|
|
// the _pSubtreeChange starts at root, so just reset pRootChange
|
|
pRootChange = pAddedChange;
|
|
}
|
|
OSL_ASSERT(pRootChange.get() != NULL);
|
|
|
|
if (m_pPending.get() == NULL)
|
|
{
|
|
// no merge is need, because the existing pending changes are empty
|
|
m_pPending = pRootChange;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
// We need to merge the new rebased changes into the m_pPending
|
|
combineUpdates(*pRootChange,*m_pPending);
|
|
}
|
|
catch (configuration::Exception& e)
|
|
{
|
|
OUString sMessage(RTL_CONSTASCII_USTRINGPARAM("Update cache for module: Could not add pending changes at"));
|
|
|
|
sMessage += aRootLocation.toString();
|
|
|
|
sMessage += OUString(RTL_CONSTASCII_USTRINGPARAM(". Internal Exception:")) + e.message();
|
|
|
|
throw uno::RuntimeException(sMessage,0);
|
|
}
|
|
}
|
|
|
|
OSL_POSTCOND(m_pPending.get() != NULL, "Could not insert new pending changes");
|
|
}
|
|
// -----------------------------------------------------------------------------
|
|
|
|
|
|
} // namespace configmgr
|
|
|
|
|