Use a standard Callable interface for lazy initialized lists

2 files changed, 27 insertions, 22 deletions

diff --git a/main/src/cgeo/geocaching/Geocache.java b/main/src/cgeo/geocaching/Geocache.java
index 6507746..eb74d8c 100644
--- a/main/src/cgeo/geocaching/Geocache.java
+++ b/main/src/cgeo/geocaching/Geocache.java
@@ -97,20 +97,20 @@ public class Geocache implements ICache, IWaypoint {
     private boolean onWatchlist = false;
     private List<String> attributes = new LazyInitializedList<String>() {
         @Override
-        protected List<String> loadFromDatabase() {
+        public List<String> call() {
             return cgData.loadAttributes(geocode);
         }
     };
     private List<Waypoint> waypoints = new LazyInitializedList<Waypoint>() {
         @Override
-        protected List<Waypoint> loadFromDatabase() {
+        public List<Waypoint> call() {
             return cgData.loadWaypoints(geocode);
         }
     };
     private List<Image> spoilers = null;
     private List<LogEntry> logs = new LazyInitializedList<LogEntry>() {
         @Override
-        protected List<LogEntry> loadFromDatabase() {
+        public List<LogEntry> call() {
             return cgData.loadLogs(geocode);
         }
     };
diff --git a/main/src/cgeo/geocaching/utils/LazyInitializedList.java b/main/src/cgeo/geocaching/utils/LazyInitializedList.java
index d9c3897..27649e8 100644
--- a/main/src/cgeo/geocaching/utils/LazyInitializedList.java
+++ b/main/src/cgeo/geocaching/utils/LazyInitializedList.java
@@ -1,58 +1,63 @@
 package cgeo.geocaching.utils;
 
 import java.util.AbstractList;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.Callable;
 
-public abstract class LazyInitializedList<ElementType> extends AbstractList<ElementType> {
+public abstract class LazyInitializedList<ElementType> extends AbstractList<ElementType> implements Callable<List<ElementType>> {
 
     private volatile List<ElementType> list;
 
-    private void initializeList() {
+    private List<ElementType> getList() {
         if (list == null) {
-            synchronized (this) {
-                if (list == null) {
-                    list = loadFromDatabase();
+            synchronized(this) {
+                try {
+                    list = call();
+                    if (list == null) {
+                        Log.e("LazyInitializedList.getList: null result");
+                    }
+                } catch (final Exception e) {
+                    Log.e("LazyInitializedList.getList", e);
                 }
             }
         }
+        return list;
     }
 
-    protected abstract List<ElementType> loadFromDatabase();
-
     @Override
     public boolean add(final ElementType element) {
-        initializeList();
-        return list.add(element);
+        return getList().add(element);
     }
 
     @Override
     public ElementType set(final int index, final ElementType element) {
-        initializeList();
-        return list.set(index, element);
+        return getList().set(index, element);
     }
 
     @Override
     public ElementType remove(final int index) {
-        initializeList();
-        return list.remove(index);
+        return getList().remove(index);
     }
 
     @Override
     public void add(int index, final ElementType element) {
-        initializeList();
-        list.add(index, element);
+        getList().add(index, element);
     }
 
     @Override
     public int size() {
-        initializeList();
-        return list.size();
+        return getList().size();
     }
 
     @Override
     public ElementType get(final int index) {
-        initializeList();
-        return list.get(index);
+        return getList().get(index);
+    }
+
+    @Override
+    public void clear() {
+        list = new ArrayList<ElementType>();
     }
 
 }