WaitableSignal was factored out from GradleFilesClassPathProvider

kelemen · Sep 22, 2012 · 38d6ae5 · 38d6ae5
1 parent 4c5b9a8
commit 38d6ae5
Show file tree

Hide file tree

Showing 2 changed files with 48 additions and 46 deletions.
diff --git a/src/org/netbeans/gradle/project/WaitableSignal.java b/src/org/netbeans/gradle/project/WaitableSignal.java
@@ -0,0 +1,45 @@
+package org.netbeans.gradle.project;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public final class WaitableSignal {
+    private final Lock lock;
+    private final Condition signalEvent;
+    private volatile boolean signaled;
+
+    public WaitableSignal() {
+        this.lock = new ReentrantLock();
+        this.signalEvent = this.lock.newCondition();
+        this.signaled = false;
+    }
+
+    public void signal() {
+        lock.lock();
+        try {
+            signaled = true;
+            signalEvent.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public boolean tryWaitForSignal() {
+        if (signaled) {
+            return true;
+        }
+        lock.lock();
+        try {
+            while (!signaled) {
+                signalEvent.await();
+            }
+        } catch (InterruptedException ex) {
+            Thread.currentThread().interrupt();
+        } finally {
+            lock.unlock();
+        }
+        return signaled;
+    }
+
+}
diff --git a/src/org/netbeans/gradle/project/query/GradleFilesClassPathProvider.java b/src/org/netbeans/gradle/project/query/GradleFilesClassPathProvider.java
@@ -14,9 +14,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.swing.SwingUtilities;
@@ -26,6 +23,7 @@
 import org.netbeans.api.java.classpath.JavaClassPathConstants;
 import org.netbeans.api.java.platform.JavaPlatform;
 import org.netbeans.gradle.project.NbGradleProject;
+import org.netbeans.gradle.project.WaitableSignal;
 import org.netbeans.gradle.project.properties.GlobalGradleSettings;
 import org.netbeans.spi.java.classpath.ClassPathFactory;
 import org.netbeans.spi.java.classpath.ClassPathImplementation;
@@ -41,7 +39,7 @@ public final class GradleFilesClassPathProvider implements ClassPathProvider {
     private static final Logger LOGGER = Logger.getLogger(GradleFilesClassPathProvider.class.getName());
 
     private final AtomicBoolean initialized;
-    private final SimpleSignal initSignal;
+    private final WaitableSignal initSignal;
     private final ConcurrentMap<ClassPathType, List<PathResourceImplementation>> classpathResources;
     private final Map<ClassPathType, ClassPath> classpaths;
 
@@ -50,7 +48,7 @@ public final class GradleFilesClassPathProvider implements ClassPathProvider {
     @SuppressWarnings("MapReplaceableByEnumMap") // no, it's not.
     public GradleFilesClassPathProvider() {
         this.initialized = new AtomicBoolean(false);
-        this.initSignal = new SimpleSignal();
+        this.initSignal = new WaitableSignal();
         this.classpaths = new EnumMap<ClassPathType, ClassPath>(ClassPathType.class);
         this.classpathResources = new ConcurrentHashMap<ClassPathType, List<PathResourceImplementation>>();
 
@@ -226,47 +224,6 @@ public void removePropertyChangeListener(PropertyChangeListener listener) {
         }
     }
 
-    private static class SimpleSignal {
-        private final Lock lock;
-        private final Condition signalEvent;
-        private volatile boolean signaled;
-
-        public SimpleSignal() {
-            this.lock = new ReentrantLock();
-            this.signalEvent = this.lock.newCondition();
-            this.signaled = false;
-        }
-
-        public void signal() {
-            lock.lock();
-            try {
-                signaled = true;
-                signalEvent.signalAll();
-            } finally {
-                lock.unlock();
-            }
-        }
-
-        public boolean tryWaitForSignal() {
-            if (signaled) {
-                return true;
-            }
-
-            lock.lock();
-            try {
-                while (!signaled) {
-                    signalEvent.await();
-                }
-            } catch (InterruptedException ex) {
-                Thread.currentThread().interrupt();
-            } finally {
-                lock.unlock();
-            }
-
-            return signaled;
-        }
-    }
-
     private enum ClassPathType {
         BOOT,
         COMPILE,