configmgr/source/inc/confevents.hxx

   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.hxx,v $
  10  * $Revision: 1.10 $
  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 #ifndef CONFIGMGR_API_EVENTS_HXX_
  32 #define CONFIGMGR_API_EVENTS_HXX_
  33
  34 #include <hash_set>
  35 #include <map>
  36 #include <set>
  37
  38 #include "osl/mutex.hxx"
  39 #include "rtl/ref.hxx"
  40 #include "salhelper/simplereferenceobject.hxx"
  41
  42 #include "configpath.hxx"
  43 #include "utility.hxx"
  44
  45 namespace rtl { class OUString; }
  46
  47 namespace configmgr
  48 {
  49     class Change;
  50     struct TreeChangeList;
  51     class TreeManager;
  52
  53     namespace configuration { class AbsolutePath; }
  54
  55     struct IConfigListener : public salhelper::SimpleReferenceObject
  56     {
  57         virtual void disposing(TreeManager * pSource) = 0;
  58     };
  59     struct INodeListener : IConfigListener
  60     {
  61         virtual void nodeChanged(Change const& aChange, configuration::AbsolutePath const& aPath, TreeManager * pSource) = 0;
  62         virtual void nodeDeleted(configuration::AbsolutePath const& aPath, TreeManager * pSource) = 0;
  63     };
  64
  65     namespace internal
  66     {
  67
  68     ////////////////////////////////////////////////////////////////////////
  69         template <class ListenerRef>
  70         class BroadcastImplHelper
  71         {
  72         public:
  73             osl::Mutex mutex;
  74
  75         public:
  76             BroadcastImplHelper()
  77             {}
  78
  79             ~BroadcastImplHelper()
  80             {
  81                 OSL_ENSURE(m_aInterfaces.empty(), "Configuration Broadcaster was not disposed properly");
  82             }
  83
  84         public:
  85             typedef std::set<ListenerRef> Interfaces;
  86
  87         public:
  88             typename Interfaces::iterator addListener(ListenerRef aListener)
  89             {
  90                 return m_aInterfaces.insert(aListener).first;
  91             }
  92             void removeListener(ListenerRef aListener)
  93             {
  94                 m_aInterfaces.erase(aListener);
  95             }
  96
  97             void disposing(TreeManager * pSource);
  98
  99         public:
 100             typename Interfaces::const_iterator begin() const { return m_aInterfaces.begin(); }
 101             typename Interfaces::const_iterator end() const { return m_aInterfaces.end(); }
 102
 103             typename Interfaces::const_iterator find(ListenerRef aListener) const   { return m_aInterfaces.find(aListener); }
 104             typename Interfaces::iterator findFull(ListenerRef aListener) { return m_aInterfaces.find(aListener); }
 105         private:
 106             Interfaces m_aInterfaces;
 107
 108             // no implementation - not copyable
 109             BroadcastImplHelper(BroadcastImplHelper&);
 110             void operator=(BroadcastImplHelper&);
 111         };
 112
 113         ////////////////////////////////////////////////////////////////////////
 114         template <class Listener>
 115         void BroadcastImplHelper<Listener>::disposing(TreeManager * pSource)
 116         {
 117             osl::ClearableMutexGuard aGuard(this->mutex);       // ensure that no notifications are running
 118
 119             Interfaces aTargets;
 120             aTargets.swap(m_aInterfaces);
 121
 122             aGuard.clear();
 123             for(typename Interfaces::iterator it = aTargets.begin(); it != aTargets.end(); )
 124             {
 125                 typename Interfaces::iterator cur = it++;
 126                 if (*cur)
 127                     (*cur)->disposing(pSource);
 128             }
 129         }
 130
 131
 132     /////////////////////////////////////////////////////////////////////////
 133
 134         class NodeListenerInfo
 135         {
 136         public:
 137             typedef std::hash_set<configuration::AbsolutePath, configuration::Path::Hash, configuration::Path::Equiv> Pathes;
 138
 139         public:
 140             NodeListenerInfo(rtl::Reference<INodeListener> const&       pListener)
 141                 : m_pListener(pListener)
 142             {
 143             }
 144
 145         // path handling
 146             Pathes const& pathList() const { return m_aPathes; }
 147
 148             void addPath(configuration::AbsolutePath const& sPath) const { m_aPathes.insert(sPath); }
 149             void removePath(configuration::AbsolutePath const& sPath) const { m_aPathes.erase(sPath); }
 150             //void removeChildPathes(OUString const& sPath);
 151
 152         // behave as pointer for use as a 'reference' class
 153             rtl::Reference<INodeListener> get() const { return m_pListener; }
 154             rtl::Reference<INodeListener> operator->() const { return get(); }
 155             INodeListener& operator*() const { return *m_pListener; }
 156         // needed to allow if (info) ...
 157             struct HasListener;
 158             operator HasListener const*() const { return reinterpret_cast<HasListener*>(m_pListener.get()); }
 159
 160             bool operator < (NodeListenerInfo const& aInfo) const
 161             { return std::less<INodeListener*>()(m_pListener.get(), aInfo.m_pListener.get()); }
 162
 163             bool operator == (NodeListenerInfo const& aInfo) const
 164             { return !!( m_pListener == aInfo.m_pListener); }
 165
 166             bool operator > (NodeListenerInfo const& aInfo) const
 167             { return aInfo.operator < (*this); }
 168             bool operator >= (NodeListenerInfo const& aInfo) const
 169             { return !operator<(aInfo); }
 170             bool operator <= (NodeListenerInfo const& aInfo) const
 171             { return !operator>(aInfo); }
 172
 173             bool operator != (NodeListenerInfo const& aInfo) const
 174             { return !operator==(aInfo); }
 175
 176         private:
 177             rtl::Reference<INodeListener> m_pListener;
 178             mutable Pathes m_aPathes; // hack to be mutable even as set element
 179         };
 180     } // namespace
 181
 182     /////////////////////////////////////////////////////////////////////////
 183     class ConfigChangeBroadcastHelper // broadcasts changes for a given set of options
 184     {
 185     public:
 186         ConfigChangeBroadcastHelper();
 187         ~ConfigChangeBroadcastHelper();
 188
 189         void broadcast(TreeChangeList const& anUpdate, sal_Bool bError, TreeManager * pSource);
 190
 191         void addListener(configuration::AbsolutePath const& aName, rtl::Reference<INodeListener> const& );
 192         void removeListener(rtl::Reference<INodeListener> const&);
 193
 194         void dispose(TreeManager * pSource);
 195
 196     private:
 197         void add(configuration::AbsolutePath const& aPath, rtl::Reference<INodeListener> const& pListener);
 198         void remove(rtl::Reference<INodeListener> const& pListener);
 199
 200         void dispatch(Change const& rBaseChange, configuration::AbsolutePath const& sChangeLocation, sal_Bool _bError, TreeManager * pSource);
 201         void dispatch(TreeChangeList const& rList_, sal_Bool _bError, TreeManager * pSource);
 202         void disposing(TreeManager * pSource);
 203
 204         void dispatchInner(rtl::Reference<INodeListener> const& pTarget, configuration::AbsolutePath const& sTargetPath, Change const& rBaseChange, configuration::AbsolutePath const& sChangeLocation, sal_Bool _bError, TreeManager * pSource);
 205         void dispatchOuter(rtl::Reference<INodeListener> const& pTarget, configuration::AbsolutePath const& sTargetPath, Change const& rBaseChange, configuration::AbsolutePath const& sChangeLocation, sal_Bool _bError, TreeManager * pSource);
 206
 207         typedef std::multimap<configuration::AbsolutePath, internal::BroadcastImplHelper<internal::NodeListenerInfo>::Interfaces::iterator, configuration::Path::Before> PathMap;
 208         internal::BroadcastImplHelper<internal::NodeListenerInfo> m_aListeners;
 209         PathMap m_aPathMap;
 210     };
 211 } // namespace
 212
 213 #endif // CONFIGMGR_API_EVENTS_HXX_
 214
 215
 216