configmgr/source/api/confevents.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: confevents.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 <stdio.h>
  35 #include <string.h>
  36 #include "confevents.hxx"
  37 #include "configexcept.hxx"
  38 #include "treechangelist.hxx"
  39 #include <osl/diagnose.h>
  40 namespace configmgr
  41 {
  42     /////////////////////////////////////////////////////////////////////////
  43     ConfigChangeBroadcastHelper::ConfigChangeBroadcastHelper()
  44     {
  45     }
  46
  47     ConfigChangeBroadcastHelper::~ConfigChangeBroadcastHelper()
  48     {
  49         OSL_ENSURE(m_aListeners.begin() == m_aListeners.end(), "Remaining listeners found - forgot to dispose ?");
  50         OSL_ENSURE(m_aPathMap.empty(), "Spurious mappings found");
  51     }
  52
  53     /////////////////////////////////////////////////////////////////////////
  54     void ConfigChangeBroadcastHelper::dispose(TreeManager * pSource)
  55     {
  56         disposing(pSource);
  57     }
  58
  59     /////////////////////////////////////////////////////////////////////////
  60     void ConfigChangeBroadcastHelper::addListener(configuration::AbsolutePath const& aName, rtl::Reference<INodeListener> const& pHandler)
  61     {
  62         add(aName, pHandler);
  63     }
  64
  65     void ConfigChangeBroadcastHelper::removeListener(rtl::Reference<INodeListener> const& pHandler)
  66     {
  67         remove(pHandler);
  68     }
  69
  70     /////////////////////////////////////////////////////////////////////////
  71     void ConfigChangeBroadcastHelper::broadcast(TreeChangeList const& anUpdate, sal_Bool bError, TreeManager * pSource)
  72     {
  73         dispatch(anUpdate, bError, pSource);
  74     }
  75
  76 /////////////////////////////////////////////////////////////////////////
  77 void ConfigChangeBroadcastHelper::add(configuration::AbsolutePath const& aName, rtl::Reference<INodeListener> const& pListener)
  78 {
  79     osl::MutexGuard aGuard(m_aListeners.mutex);
  80
  81     internal::BroadcastImplHelper<internal::NodeListenerInfo>::Interfaces::iterator aAdded = m_aListeners.addListener(internal::NodeListenerInfo(pListener));
  82     aAdded->addPath(aName);
  83     m_aPathMap.insert(PathMap::value_type(aName,aAdded));
  84 }
  85
  86 /////////////////////////////////////////////////////////////////////////
  87 void ConfigChangeBroadcastHelper::remove(rtl::Reference<INodeListener> const& pListener)
  88 {
  89     osl::MutexGuard aGuard(m_aListeners.mutex);
  90
  91     internal::BroadcastImplHelper<internal::NodeListenerInfo>::Interfaces::const_iterator const iter = m_aListeners.find(pListener);
  92     if (iter != m_aListeners.end())
  93     {
  94         internal::NodeListenerInfo::Pathes const& pathes = iter->pathList();
  95
  96         // first clear the Path Map
  97         for(internal::NodeListenerInfo::Pathes::iterator itPath = pathes.begin(); itPath != pathes.end(); ++itPath)
  98         {
  99             std::pair<PathMap::iterator, PathMap::iterator> aRange = m_aPathMap.equal_range(*itPath);
 100             while (aRange.first != aRange.second)
 101             {
 102                 PathMap::iterator cur = aRange.first++;
 103                 if (cur->second == iter)
 104                     m_aPathMap.erase(cur);
 105             }
 106         }
 107
 108         // the remove the broadcast helper entry
 109         m_aListeners.removeListener(pListener);
 110     }
 111 }
 112
 113 /////////////////////////////////////////////////////////////////////////
 114 // This should actually be available from the TreeChangeList
 115 /////////////////////////////////////////////////////////////////////////
 116
 117 static Change const* resolvePath(Change const& rChange, configuration::RelativePath& aRelativePath, RemoveNode const*& pRemoveNode)
 118 {
 119     std::vector<configuration::Path::Component>::const_reverse_iterator aIter;
 120
 121     OSL_ASSERT(pRemoveNode == NULL);
 122     pRemoveNode = NULL;
 123
 124     Change const* pChange = &rChange;
 125     pRemoveNode = dynamic_cast<RemoveNode const*>(pChange);
 126
 127     std::vector<configuration::Path::Component>::const_reverse_iterator const aEnd(aRelativePath.end());
 128
 129     for( aIter = aRelativePath.begin();
 130          aIter != aEnd;
 131          ++aIter)
 132     {
 133         OSL_ASSERT( pChange != NULL );
 134
 135         pChange = pChange->getSubChange(aIter->getName());
 136
 137         if (pChange == NULL) break;
 138
 139         OSL_ASSERT(pRemoveNode == NULL);
 140         OSL_ASSERT(aIter->getName() == pChange->getNodeName());
 141
 142         pRemoveNode = dynamic_cast<RemoveNode const*>(pChange);
 143     }
 144
 145     if (pRemoveNode)
 146     {
 147         aRelativePath = configuration::RelativePath( configuration::Path::Rep(aRelativePath.begin(),aIter) );
 148         OSL_ASSERT( aRelativePath.getLocalName().getName() == pRemoveNode->getNodeName());
 149     }
 150     else
 151         OSL_ASSERT( pChange == 0 || configuration::matches(aRelativePath, configuration::RelativePath( configuration::Path::Rep(aRelativePath.begin(),aIter) )) );
 152
 153     return pChange;
 154 }
 155
 156 /////////////////////////////////////////////////////////////////////////
 157 void ConfigChangeBroadcastHelper::dispatchInner
 158 (
 159     rtl::Reference<INodeListener> const& pTarget,
 160     configuration::AbsolutePath const& _aTargetPath,
 161     Change const& rBaseChange,
 162     configuration::AbsolutePath const& _aChangeLocation,
 163     sal_Bool , //_bError,
 164     TreeManager * pSource
 165 )
 166 {
 167     try
 168     {
 169         OSL_ASSERT(pTarget.is());
 170         OSL_ASSERT( configuration::Path::hasPrefix( _aTargetPath, _aChangeLocation ) );
 171
 172         configuration::RelativePath aLocalPath = configuration::Path::stripPrefix( _aTargetPath, _aChangeLocation );
 173
 174         RemoveNode const* pRemoved = 0;
 175         Change const* pTargetChange = resolvePath(rBaseChange, aLocalPath, pRemoved );
 176
 177         OSL_ASSERT( !pTargetChange || matches(_aChangeLocation.compose(aLocalPath),_aTargetPath) );
 178
 179         if (pRemoved)
 180             pTarget->nodeDeleted(_aChangeLocation.compose(aLocalPath), pSource);
 181
 182         else if (pTargetChange)
 183             pTarget->nodeChanged(*pTargetChange, _aTargetPath, pSource);
 184
 185     }
 186     catch (configuration::InvalidName& )
 187     {
 188         OSL_ENSURE(false,"ConfigChangeBroadcastHelper: Could not dispatch notification: context path mismatch");
 189     }
 190 }
 191
 192 /////////////////////////////////////////////////////////////////////////
 193 void ConfigChangeBroadcastHelper::dispatchOuter
 194 (
 195     rtl::Reference<INodeListener> const& pTarget,
 196     configuration::AbsolutePath const& _aTargetPath,
 197     Change const& rBaseChange,
 198     configuration::AbsolutePath const& _aChangeLocation,
 199     sal_Bool , //_bError,
 200     TreeManager * pSource
 201 )
 202 {
 203     { (void)_aTargetPath; }
 204     OSL_ASSERT(pTarget.is());
 205     OSL_ASSERT( configuration::Path::hasPrefix( _aChangeLocation, _aTargetPath) );
 206
 207     pTarget->nodeChanged(rBaseChange, _aChangeLocation, pSource);
 208 }
 209
 210 /////////////////////////////////////////////////////////////////////////
 211 void ConfigChangeBroadcastHelper::dispatch(TreeChangeList const& rList_, sal_Bool _bError, TreeManager * pSource)
 212 {
 213     dispatch(rList_.root, rList_.getRootNodePath(),_bError, pSource);
 214 }
 215
 216 /////////////////////////////////////////////////////////////////////////
 217 namespace
 218 {
 219     struct DispatchTarget
 220     {
 221         DispatchTarget(rtl::Reference<INodeListener> _pTarget, configuration::AbsolutePath const* _pDispatchPath)
 222         : pTarget(_pTarget), pDispatchPath( _pDispatchPath) {}
 223
 224         rtl::Reference<INodeListener>    pTarget;
 225         configuration::AbsolutePath const* pDispatchPath;
 226     };
 227 }
 228 /////////////////////////////////////////////////////////////////////////
 229 void ConfigChangeBroadcastHelper::dispatch
 230 (
 231     Change const& rBaseChange,
 232     configuration::AbsolutePath const& _aChangeLocation,
 233     sal_Bool _bError,
 234     TreeManager * pSource
 235 )
 236 {
 237     OSL_ENSURE(!_aChangeLocation.isRoot(),"Cannot dispatch changes directly to the root node");
 238
 239     // listeners registered under multiple sub-pathes will be called multiple times !
 240
 241     // Collect the targets
 242     osl::ClearableMutexGuard aGuard(m_aListeners.mutex);
 243
 244     // Dispatch listeners to ancestors of the change root
 245     std::vector<DispatchTarget> aOuterTargets;
 246     if (_aChangeLocation.getDepth() > 1)
 247     {
 248         configuration::AbsolutePath const aModulePath( configuration::Path::Rep(*_aChangeLocation.begin()) );
 249
 250         PathMap::const_iterator itOuter = m_aPathMap.lower_bound( aModulePath );
 251         PathMap::const_iterator const endOuter = m_aPathMap.upper_bound(_aChangeLocation.getParentPath());
 252
 253         // TODO: Both loops are so similar - they should be a single function
 254         while (itOuter != endOuter)
 255         {
 256             OSL_ASSERT( m_aListeners.find(itOuter->second->get()) != m_aListeners.end() );
 257
 258             // check whether this should be dispatched at all
 259             if ( configuration::Path::hasPrefix(_aChangeLocation,itOuter->first) )
 260             {
 261                 aOuterTargets.push_back( DispatchTarget(itOuter->second->get(), &itOuter->first) );
 262             }
 263             ++itOuter;
 264         }
 265     }
 266
 267     // Dispatch listeners to descendants of the change root
 268     std::vector<DispatchTarget> aInnerTargets;
 269     {
 270         PathMap::const_iterator itInner = m_aPathMap.lower_bound(_aChangeLocation);
 271
 272         while(  itInner != m_aPathMap.end() && configuration::Path::hasPrefix(itInner->first,_aChangeLocation) )
 273         {
 274             OSL_ASSERT( m_aListeners.find(itInner->second->get()) != m_aListeners.end() );
 275
 276             aInnerTargets.push_back( DispatchTarget(itInner->second->get(), &itInner->first) );
 277
 278             ++itInner;
 279         }
 280     }
 281
 282     aGuard.clear();
 283
 284     {for (std::vector<DispatchTarget>::const_iterator it = aOuterTargets.begin(); it != aOuterTargets.end(); ++it){
 285         this->dispatchOuter(it->pTarget, *it->pDispatchPath, rBaseChange, _aChangeLocation, _bError, pSource);
 286     }}
 287     {for (std::vector<DispatchTarget>::const_iterator it = aInnerTargets.begin(); it != aInnerTargets.end(); ++it){
 288         this->dispatchInner(it->pTarget, *it->pDispatchPath, rBaseChange, _aChangeLocation, _bError, pSource);
 289     }}
 290 }
 291
 292 /////////////////////////////////////////////////////////////////////////
 293 void ConfigChangeBroadcastHelper::disposing(TreeManager * pSource)
 294 {
 295     osl::ClearableMutexGuard aGuard(m_aListeners.mutex);
 296     m_aPathMap.clear();
 297
 298     aGuard.clear();
 299     m_aListeners.disposing(pSource);
 300 }
 301
 302 } // namespace
 303
 304
 305