Name the loading thread and ask java to push its priority down.

[debian/openrocket] / core / src / net / sf / openrocket / database / ComponentPresetDatabase.java

diff --git a/core/src/net/sf/openrocket/database/ComponentPresetDatabase.java b/core/src/net/sf/openrocket/database/ComponentPresetDatabase.java
index 8acafcff57c1fa13362a8a16132ac1518036337b..bb2fae2b981957efa0323695f7f726f758b1451c 100644 (file)
--- a/core/src/net/sf/openrocket/database/ComponentPresetDatabase.java
+++ b/core/src/net/sf/openrocket/database/ComponentPresetDatabase.java
@@ -3,18 +3,36 @@ package net.sf.openrocket.database;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
+import net.sf.openrocket.logging.LogHelper;
 import net.sf.openrocket.preset.ComponentPreset;
 import net.sf.openrocket.startup.Application;
 
-public class ComponentPresetDatabase extends Database<ComponentPreset> implements ComponentPresetDao {
+public abstract class ComponentPresetDatabase extends Database<ComponentPreset> implements ComponentPresetDao {
+
+       private static final LogHelper logger = Application.getLogger();
+
+       private volatile boolean startedLoading = false;
+       private volatile boolean endedLoading = false;
+       private final boolean asynchronous;
+
+       /** Set to true the first time {@link #blockUntilLoaded()} is called. */
+       protected volatile boolean inUse = false;
 
        public ComponentPresetDatabase() {
                super();
+               this.asynchronous = false;
+       }
+       
+       public ComponentPresetDatabase(boolean asynchronous ) {
+               super();
+               this.asynchronous = asynchronous;
        }
 
        @Override
        public List<ComponentPreset> listAll() {
+               blockUntilLoaded();
                return list;
        }
 
@@ -25,6 +43,7 @@ public class ComponentPresetDatabase extends Database<ComponentPreset> implement
 
        @Override
        public List<ComponentPreset> listForType( ComponentPreset.Type type ) {
+               blockUntilLoaded();
                if ( type == null ) {
                        return Collections.<ComponentPreset>emptyList();
                }
@@ -50,6 +69,7 @@ public class ComponentPresetDatabase extends Database<ComponentPreset> implement
         */
        @Override
        public List<ComponentPreset> listForType( ComponentPreset.Type type, boolean favorite ) {
+               blockUntilLoaded();
 
                if ( !favorite ) {
                        return listForType(type);
@@ -57,8 +77,10 @@ public class ComponentPresetDatabase extends Database<ComponentPreset> implement
 
                List<ComponentPreset> result = new ArrayList<ComponentPreset>(list.size()/6);
 
+               Set<String> favorites = Application.getPreferences().getComponentFavorites(type);
+
                for( ComponentPreset preset : list ) {
-                       if ( preset.isFavorite() && preset.get(ComponentPreset.TYPE).equals(type) ) {
+                       if ( preset.get(ComponentPreset.TYPE).equals(type) && favorites.contains(preset.preferenceKey())) {
                                result.add(preset);
                        }
                }
@@ -67,6 +89,7 @@ public class ComponentPresetDatabase extends Database<ComponentPreset> implement
 
        @Override
        public List<ComponentPreset> listForTypes( ComponentPreset.Type ... type ) {
+               blockUntilLoaded();
 
                if( type == null || type.length == 0 ) {
                        return Collections.<ComponentPreset>emptyList();
@@ -93,11 +116,13 @@ public class ComponentPresetDatabase extends Database<ComponentPreset> implement
 
        @Override
        public List<ComponentPreset> listForTypes( List<ComponentPreset.Type> types ) {
+               blockUntilLoaded();
                return listForTypes( (ComponentPreset.Type[]) types.toArray() );
        }
 
        @Override
        public List<ComponentPreset> find(String manufacturer, String partNo) {
+               blockUntilLoaded();
                List<ComponentPreset> presets = new ArrayList<ComponentPreset>();
                for( ComponentPreset preset : list ) {
                        if ( preset.getManufacturer().getSimpleName().equals(manufacturer) && preset.getPartNo().equals(partNo) ) {
@@ -108,10 +133,76 @@ public class ComponentPresetDatabase extends Database<ComponentPreset> implement
        }
 
        @Override
-       public void setFavorite( ComponentPreset preset, boolean favorite ) {
-               preset.setFavorite(favorite);
-               Application.getPreferences().setComponentFavorite( preset, favorite );
+       public void setFavorite( ComponentPreset preset, ComponentPreset.Type type, boolean favorite ) {
+               blockUntilLoaded();
+               Application.getPreferences().setComponentFavorite( preset, type, favorite );
                this.fireAddEvent(preset);
        }
 
+
+       /**
+        * Used for loading the component preset database.  This method will be called in a background
+        * thread to load the presets asynchronously.
+        */
+       protected abstract void load();
+
+       /**
+        * Start loading the presets.
+        * 
+        * @throws  IllegalStateException       if this method has already been called.
+        */
+       public void startLoading() {
+               if (startedLoading) {
+                       throw new IllegalStateException("Already called startLoading");
+               }
+               startedLoading = true;
+               if (asynchronous) {
+                       new LoadingThread().start();
+               } else {
+                       load();
+               }
+               synchronized (this) {
+                       endedLoading = true;
+                       this.notifyAll();
+               }
+       }
+
+       /**
+        * Background thread for loading the presets. 
+        */
+       private class LoadingThread extends Thread {
+               
+               private LoadingThread() {
+                       this.setName("PresetLoadingThread");
+                       this.setPriority(MIN_PRIORITY);
+               }
+               @Override
+               public void run() {
+                       load();
+               }
+       }
+
+       /**
+        * Block the current thread until loading of the presets has been completed.
+        * 
+        * @throws IllegalStateException        if startLoading() has not been called.
+        */
+       public void blockUntilLoaded() {
+               inUse = true;
+               if (!startedLoading) {
+                       throw new IllegalStateException("startLoading() has not been called");
+               }
+               if (!endedLoading) {
+                       synchronized (this) {
+                               while (!endedLoading) {
+                                       try {
+                                               this.wait();
+                                       } catch (InterruptedException e) {
+                                               logger.warn("InterruptedException occurred, ignoring", e);
+                                       }
+                               }
+                       }
+               }
+       }
+
 }