cli_ure/source/ure/uno/util/WeakComponentBase.cs

   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: WeakComponentBase.cs,v $
  10  * $Revision: 1.5 $
  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 using System;
  32 using unoidl.com.sun.star.lang;
  33
  34 namespace uno.util
  35 {
  36
  37 /** This class can be used as a base class for UNO objects.
  38     It implements the capability to be kept weakly
  39     (unoidl.com.sun.star.uno.XWeak) and it implements
  40     unoidl.com.sun.star.lang.XTypeProvider which is necessary for
  41     using the object from StarBasic.
  42     In addition, it implements the interface
  43     unoidl.com.sun.star.lang.XComponent to be disposed explicitly.
  44 */
  45 public class WeakComponentBase : WeakBase, XComponent
  46 {
  47     private delegate void t_disposing( EventObject evt );
  48     private t_disposing m_disposing = null;
  49     private bool m_inDispose = false;
  50     private bool m_disposed = false;
  51
  52     /** Indicates whether object is alrady disposed.
  53
  54         @return
  55                 true, if object has been disposed
  56     */
  57     protected bool isDisposed()
  58     {
  59         lock (this)
  60         {
  61             return m_disposed;
  62         }
  63     }
  64
  65     /** Checks whether this object is disposed and throws a DisposedException
  66         if it is already disposed.
  67     */
  68     protected void checkUnDisposed()
  69     {
  70         if (! isDisposed())
  71         {
  72             throw new unoidl.com.sun.star.lang.DisposedException(
  73                 "object already disposed!", this );
  74         }
  75     }
  76
  77     ~WeakComponentBase()
  78     {
  79         bool doDispose;
  80         lock (this)
  81         {
  82             doDispose = (!m_inDispose && !m_disposed);
  83         }
  84         if (doDispose)
  85         {
  86             dispose();
  87         }
  88     }
  89
  90     /** Override to perform extra clean-up work. Provided for subclasses.
  91         It is called during dispose()
  92     */
  93     protected void preDisposing()
  94     {
  95     }
  96
  97     /** Override to become notified right before the disposing action is
  98         performed.
  99     */
 100     protected void postDisposing()
 101     {
 102     }
 103
 104     // XComponent impl
 105     /** This method is called by the owner of this object to explicitly
 106         dispose it.  This implementation of dispose() first notifies this object
 107         via preDisposing(), then  all registered event listeners and
 108         finally this object again calling postDisposing().
 109     */
 110     public void dispose()
 111     {
 112         // Determine in a thread-safe way if this is the first call to this
 113         // method.  Only then we proceed with the notification of event
 114         // listeners.  It is an error to call this method more then once.
 115         bool doDispose = false;
 116         t_disposing call = null;
 117         lock (this)
 118         {
 119             if (! m_inDispose && !m_disposed)
 120             {
 121                 call = m_disposing;
 122                 m_disposing = null;
 123                 m_inDispose = true;
 124                 doDispose = true;
 125             }
 126         }
 127         // The notification occures in an unsynchronized block in order to avoid
 128         // deadlocks if one of the listeners calls back in a different thread on
 129         // a synchronized method which uses the same object.
 130         if (doDispose)
 131         {
 132             try
 133             {
 134                 // call sub class
 135                 preDisposing();
 136                 // send disposing notifications to listeners
 137                 if (null != call)
 138                 {
 139                     EventObject evt = new EventObject( this );
 140                     call( evt );
 141                 }
 142                 // call sub class
 143                 postDisposing();
 144             }
 145             finally
 146             {
 147                 // finally makes sure that the flags are set ensuring
 148                 // that this function is only called once.
 149                 m_disposed = true;
 150                 m_inDispose = false;
 151             }
 152         }
 153         else
 154         {
 155             // in a multithreaded environment, it can't be avoided,
 156             // that dispose is called twice.
 157             // However this condition is traced, because it MAY indicate an
 158             // error.
 159 #if DEBUG
 160             Console.WriteLine(
 161                 "WeakComponentBase.dispose() - dispose called twice" );
 162 #endif
 163 //             Debug.Fail( "WeakComponentBase.dispose() - dispose called twice" );
 164         }
 165     }
 166     /** Registers an event listener being notified when this object is disposed.
 167
 168         @param xListener event listener
 169     */
 170     public void addEventListener( XEventListener xListener )
 171     {
 172         bool add;
 173         lock (this)
 174         {
 175             add = (! m_inDispose && !m_disposed);
 176             if (add)
 177                 m_disposing += new t_disposing( xListener.disposing );
 178         }
 179         if (! add)
 180             xListener.disposing( new EventObject( this ) );
 181     }
 182     /** Revokes an event listener from being notified when this object
 183         is disposed.
 184
 185         @param xListener event listener
 186     */
 187     public void removeEventListener( XEventListener xListener )
 188     {
 189         lock (this)
 190         {
 191             if (! m_inDispose && !m_disposed)
 192                 m_disposing -= new t_disposing( xListener.disposing );
 193         }
 194     }
 195 }
 196
 197 }