bundles/org.simantics.utils.datastructures/src/org/simantics/utils/datastructures/disposable/AbstractDisposable.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 \r
  13 /*\r
  14  *\r
  15  * @author Toni Kalajainen\r
  16  */\r
  17 package org.simantics.utils.datastructures.disposable;\r
  18 \r
  19 import java.lang.reflect.Method;\r
  20 \r
  21 import org.simantics.utils.threads.IThreadWorkQueue;\r
  22 import org.simantics.utils.threads.SyncListenerList;\r
  23 \r
  24 /**\r
  25  * Base implementation of IDisposable. The subclass must implement doDispose()\r
  26  * method. It invoked at once in first dispose call. Subsequent calls to dispose\r
  27  * throws an AssertionError.\r
  28  * <p>\r
  29  * assertNotDisposed() ensures that the object has not beed disposed. If so,\r
  30  * AssertionError is thrown. assertNotDisposed() should be installed in all\r
  31  * public methods of subclass.\r
  32  * <p>\r
  33  * Object is disposed in finalize, if dispose has not been invoked explicitely.\r
  34  */\r
  35 public abstract class AbstractDisposable implements IDisposable {\r
  36 \r
  37     SyncListenerList<IDisposeListener> disposeListeners = null;\r
  38 \r
  39     private DisposeState disposeStatus = DisposeState.Alive;\r
  40 \r
  41     protected void assertNotDisposed() {\r
  42         if (isDisposed())\r
  43             throw new AssertionError(this + " is disposed.");\r
  44     }\r
  45 \r
  46     @Override\r
  47     public DisposeState getDisposeState() {\r
  48         return disposeStatus;\r
  49     }\r
  50     \r
  51     public boolean isDisposed() {\r
  52         return disposeStatus == DisposeState.Disposed;\r
  53     }\r
  54     \r
  55     public boolean isAlive() {\r
  56         return disposeStatus == DisposeState.Alive;\r
  57     }\r
  58     \r
  59     @Override\r
  60     public void dispose() {\r
  61         try {\r
  62             synchronized (this) {\r
  63                 if (disposeStatus == DisposeState.Disposing)\r
  64                     return;\r
  65                 assertNotDisposed();\r
  66                 disposeStatus = DisposeState.Disposing;\r
  67             }\r
  68             try {\r
  69                 fireDisposed();\r
  70             } finally {\r
  71                 doDispose();\r
  72             }\r
  73         } finally {\r
  74             synchronized(this) {\r
  75                 disposeStatus = DisposeState.Disposed;\r
  76             }\r
  77         }\r
  78     }\r
  79     \r
  80     /**\r
  81      * Disposes if not disposed\r
  82      */\r
  83     public void safeDispose() {        \r
  84         try {\r
  85             synchronized (this) {\r
  86                 if (disposeStatus != DisposeState.Alive)\r
  87                     return;\r
  88                 disposeStatus = DisposeState.Disposing;\r
  89             }\r
  90             try {\r
  91                 fireDisposed();\r
  92             } finally {\r
  93                 doDispose();\r
  94             }\r
  95         } finally {\r
  96             synchronized(this) {\r
  97                 disposeStatus = DisposeState.Disposed;\r
  98             }\r
  99         }\r
 100     }\r
 101 \r
 102     /**\r
 103      * Do dispose procedures. This method is invoked at most once.\r
 104      */\r
 105     protected abstract void doDispose();\r
 106 \r
 107     protected boolean hasDisposeListeners() {\r
 108         return disposeListeners!=null && !disposeListeners.isEmpty();\r
 109     }\r
 110 \r
 111     private final static Method onDisposed = SyncListenerList.getMethod(IDisposeListener.class, "onDisposed");\r
 112 \r
 113     private void fireDisposed() {\r
 114         if (disposeListeners==null) return;\r
 115         disposeListeners.fireEventSync(onDisposed, this);\r
 116     }\r
 117 \r
 118     @SuppressWarnings("unused")\r
 119     private void fireDisposedAsync() {\r
 120         if (disposeListeners==null) return;\r
 121         disposeListeners.fireEventAsync(onDisposed, this);\r
 122     }\r
 123 \r
 124     @Override\r
 125     public void addDisposeListener(IDisposeListener listener) {\r
 126         lazyGetListenerList().add(listener);\r
 127     }\r
 128 \r
 129     @Override\r
 130     public void addDisposeListener(IDisposeListener listener, IThreadWorkQueue thread) {\r
 131         lazyGetListenerList().add(thread, listener);\r
 132     }\r
 133 \r
 134     @Override\r
 135     public void removeDisposeListener(IDisposeListener listener) {\r
 136         if (disposeListeners==null) return;\r
 137         disposeListeners.remove(listener);\r
 138     }\r
 139 \r
 140     @Override\r
 141     public void removeDisposeListener(IDisposeListener listener, IThreadWorkQueue thread) {\r
 142         if (disposeListeners==null) return;\r
 143         disposeListeners.remove(thread, listener);\r
 144     }\r
 145     \r
 146     private synchronized SyncListenerList<IDisposeListener> lazyGetListenerList()\r
 147     {\r
 148         if (disposeListeners==null)\r
 149             disposeListeners = new SyncListenerList<IDisposeListener>(IDisposeListener.class);\r
 150         return disposeListeners;\r
 151     }\r
 152     \r
 153     /*\r
 154     @Override\r
 155     protected void finalize() throws Throwable {\r
 156         try {\r
 157             safeDispose();\r
 158         } finally {\r
 159             super.finalize();\r
 160         }\r
 161     }\r
 162     */\r
 163     \r
 164 }\r