fix several name shadowing occurrences

13 files changed, 75 insertions, 77 deletions

diff --git a/main/src/cgeo/geocaching/CacheDetailActivity.java b/main/src/cgeo/geocaching/CacheDetailActivity.java
index f0e0ca4..8b852cf 100644
--- a/main/src/cgeo/geocaching/CacheDetailActivity.java
+++ b/main/src/cgeo/geocaching/CacheDetailActivity.java
@@ -377,14 +377,14 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc
             case R.id.menu_waypoint_duplicate:
                 ensureSaved();
                 if (cache.duplicateWaypoint(selectedWaypoint)) {
-                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
                     notifyDataSetChanged();
                 }
                 return true;
             case R.id.menu_waypoint_delete:
                 ensureSaved();
                 if (cache.deleteWaypoint(selectedWaypoint)) {
-                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
                     notifyDataSetChanged();
                 }
                 return true;
@@ -2098,7 +2098,7 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc
         }
     }
 
-    private class UploadPersonalNoteThread extends Thread {
+    private static class UploadPersonalNoteThread extends Thread {
         private Geocache cache = null;
         private CancellableHandler handler = null;
 
@@ -2115,7 +2115,7 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc
             }
             final Message msg = Message.obtain();
             final Bundle bundle = new Bundle();
-            bundle.putString(SimpleCancellableHandler.MESSAGE_TEXT, res.getString(R.string.cache_personal_note_upload_done));
+            bundle.putString(SimpleCancellableHandler.MESSAGE_TEXT, CgeoApplication.getInstance().getString(R.string.cache_personal_note_upload_done));
             msg.setData(bundle);
             handler.sendMessage(msg);
         }
@@ -2314,7 +2314,7 @@ public class CacheDetailActivity extends AbstractViewPagerActivity<CacheDetailAc
                     cache.parseWaypointsFromNote();
                     final TextView personalNoteView = (TextView) activity.findViewById(R.id.personalnote);
                     setPersonalNote(personalNoteView, note);
-                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
                     activity.notifyDataSetChanged();
                 }
             };
diff --git a/main/src/cgeo/geocaching/CacheListActivity.java b/main/src/cgeo/geocaching/CacheListActivity.java
index 1892cbc..0eded88 100644
--- a/main/src/cgeo/geocaching/CacheListActivity.java
+++ b/main/src/cgeo/geocaching/CacheListActivity.java
@@ -260,7 +260,7 @@ public class CacheListActivity extends AbstractListActivity implements FilteredA
         }
     }
 
-    private String getCacheNumberString(final Resources res, final int count) {
+    private static String getCacheNumberString(final Resources res, final int count) {
         return res.getQuantityString(R.plurals.cache_counts, count, count);
     }
 
diff --git a/main/src/cgeo/geocaching/DataStore.java b/main/src/cgeo/geocaching/DataStore.java
index bdbb97e..c368586 100644
--- a/main/src/cgeo/geocaching/DataStore.java
+++ b/main/src/cgeo/geocaching/DataStore.java
@@ -1122,7 +1122,7 @@ public class DataStore {
 
             // Only save the cache in the database if it is requested by the caller and
             // the cache contains detailed information.
-            if (saveFlags.contains(SaveFlag.SAVE_DB) && cache.isDetailed() && dbUpdateRequired) {
+            if (saveFlags.contains(SaveFlag.DB) && cache.isDetailed() && dbUpdateRequired) {
                 toBeStored.add(cache);
             }
         }
@@ -1565,7 +1565,7 @@ public class DataStore {
         final Set<Geocache> result = new HashSet<Geocache>();
         final Set<String> remaining = new HashSet<String>(geocodes);
 
-        if (loadFlags.contains(LoadFlag.LOAD_CACHE_BEFORE)) {
+        if (loadFlags.contains(LoadFlag.CACHE_BEFORE)) {
             for (final String geocode : new HashSet<String>(remaining)) {
                 final Geocache cache = cacheCache.getCacheFromCache(geocode);
                 if (cache != null) {
@@ -1575,13 +1575,13 @@ public class DataStore {
             }
         }
 
-        if (loadFlags.contains(LoadFlag.LOAD_DB_MINIMAL) ||
-                loadFlags.contains(LoadFlag.LOAD_ATTRIBUTES) ||
-                loadFlags.contains(LoadFlag.LOAD_WAYPOINTS) ||
-                loadFlags.contains(LoadFlag.LOAD_SPOILERS) ||
-                loadFlags.contains(LoadFlag.LOAD_LOGS) ||
-                loadFlags.contains(LoadFlag.LOAD_INVENTORY) ||
-                loadFlags.contains(LoadFlag.LOAD_OFFLINE_LOG)) {
+        if (loadFlags.contains(LoadFlag.DB_MINIMAL) ||
+                loadFlags.contains(LoadFlag.ATTRIBUTES) ||
+                loadFlags.contains(LoadFlag.WAYPOINTS) ||
+                loadFlags.contains(LoadFlag.SPOILERS) ||
+                loadFlags.contains(LoadFlag.LOGS) ||
+                loadFlags.contains(LoadFlag.INVENTORY) ||
+                loadFlags.contains(LoadFlag.OFFLINE_LOG)) {
 
             final Set<Geocache> cachesFromDB = loadCachesFromGeocodes(remaining, loadFlags);
             result.addAll(cachesFromDB);
@@ -1590,7 +1590,7 @@ public class DataStore {
             }
         }
 
-        if (loadFlags.contains(LoadFlag.LOAD_CACHE_AFTER)) {
+        if (loadFlags.contains(LoadFlag.CACHE_AFTER)) {
             for (final String geocode : new HashSet<String>(remaining)) {
                 final Geocache cache = cacheCache.getCacheFromCache(geocode);
                 if (cache != null) {
@@ -1622,12 +1622,12 @@ public class DataStore {
         init();
 
         final StringBuilder query = new StringBuilder(QUERY_CACHE_DATA);
-        if (loadFlags.contains(LoadFlag.LOAD_OFFLINE_LOG)) {
+        if (loadFlags.contains(LoadFlag.OFFLINE_LOG)) {
             query.append(',').append(dbTableLogsOffline).append(".log");
         }
 
         query.append(" FROM ").append(dbTableCaches);
-        if (loadFlags.contains(LoadFlag.LOAD_OFFLINE_LOG)) {
+        if (loadFlags.contains(LoadFlag.OFFLINE_LOG)) {
             query.append(" LEFT OUTER JOIN ").append(dbTableLogsOffline).append(" ON ( ").append(dbTableCaches).append(".geocode == ").append(dbTableLogsOffline).append(".geocode) ");
         }
 
@@ -1642,23 +1642,23 @@ public class DataStore {
             while (cursor.moveToNext()) {
                 final Geocache cache = DataStore.createCacheFromDatabaseContent(cursor);
 
-                if (loadFlags.contains(LoadFlag.LOAD_ATTRIBUTES)) {
+                if (loadFlags.contains(LoadFlag.ATTRIBUTES)) {
                     cache.setAttributes(loadAttributes(cache.getGeocode()));
                 }
 
-                if (loadFlags.contains(LoadFlag.LOAD_WAYPOINTS)) {
+                if (loadFlags.contains(LoadFlag.WAYPOINTS)) {
                     final List<Waypoint> waypoints = loadWaypoints(cache.getGeocode());
                     if (CollectionUtils.isNotEmpty(waypoints)) {
                         cache.setWaypoints(waypoints, false);
                     }
                 }
 
-                if (loadFlags.contains(LoadFlag.LOAD_SPOILERS)) {
+                if (loadFlags.contains(LoadFlag.SPOILERS)) {
                     final List<Image> spoilers = loadSpoilers(cache.getGeocode());
                     cache.setSpoilers(spoilers);
                 }
 
-                if (loadFlags.contains(LoadFlag.LOAD_LOGS)) {
+                if (loadFlags.contains(LoadFlag.LOGS)) {
                     final Map<LogType, Integer> logCounts = loadLogCounts(cache.getGeocode());
                     if (MapUtils.isNotEmpty(logCounts)) {
                         cache.getLogCounts().clear();
@@ -1666,7 +1666,7 @@ public class DataStore {
                     }
                 }
 
-                if (loadFlags.contains(LoadFlag.LOAD_INVENTORY)) {
+                if (loadFlags.contains(LoadFlag.INVENTORY)) {
                     final List<Trackable> inventory = loadInventory(cache.getGeocode());
                     if (CollectionUtils.isNotEmpty(inventory)) {
                         if (cache.getInventory() == null) {
@@ -1678,7 +1678,7 @@ public class DataStore {
                     }
                 }
 
-                if (loadFlags.contains(LoadFlag.LOAD_OFFLINE_LOG)) {
+                if (loadFlags.contains(LoadFlag.OFFLINE_LOG)) {
                     if (logIndex < 0) {
                         logIndex = cursor.getColumnIndex("log");
                     }
@@ -2412,13 +2412,13 @@ public class DataStore {
 
         init();
 
-        if (removeFlags.contains(RemoveFlag.REMOVE_CACHE)) {
+        if (removeFlags.contains(RemoveFlag.CACHE)) {
             for (final String geocode : geocodes) {
                 cacheCache.removeCacheFromCache(geocode);
             }
         }
 
-        if (removeFlags.contains(RemoveFlag.REMOVE_DB)) {
+        if (removeFlags.contains(RemoveFlag.DB)) {
             // Drop caches from the database
             final ArrayList<String> quotedGeocodes = new ArrayList<String>(geocodes.size());
             for (final String geocode : geocodes) {
@@ -2436,7 +2436,7 @@ public class DataStore {
                 database.delete(dbTableLogCount, baseWhereClause, null);
                 database.delete(dbTableLogsOffline, baseWhereClause, null);
                 String wayPointClause = baseWhereClause;
-                if (!removeFlags.contains(RemoveFlag.REMOVE_OWN_WAYPOINTS_ONLY_FOR_TESTING)) {
+                if (!removeFlags.contains(RemoveFlag.OWN_WAYPOINTS_ONLY_FOR_TESTING)) {
                     wayPointClause += " and type <> 'own'";
                 }
                 database.delete(dbTableWaypoints, wayPointClause, null);
@@ -2914,7 +2914,7 @@ public class DataStore {
     }
 
     public static void saveChangedCache(final Geocache cache) {
-        DataStore.saveCache(cache, cache.getStorageLocation().contains(StorageLocation.DATABASE) ? LoadFlags.SAVE_ALL : EnumSet.of(SaveFlag.SAVE_CACHE));
+        DataStore.saveCache(cache, cache.getStorageLocation().contains(StorageLocation.DATABASE) ? LoadFlags.SAVE_ALL : EnumSet.of(SaveFlag.CACHE));
     }
 
     private static class PreparedStatements {
@@ -3045,7 +3045,7 @@ public class DataStore {
 
     public static boolean saveWaypoint(final int id, final String geocode, final Waypoint waypoint) {
         if (DataStore.saveWaypointInternal(id, geocode, waypoint)) {
-            DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+            DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.CACHE));
             return true;
         }
         return false;
diff --git a/main/src/cgeo/geocaching/EditWaypointActivity.java b/main/src/cgeo/geocaching/EditWaypointActivity.java
index 0eeb0d7..ccb25f5 100644
--- a/main/src/cgeo/geocaching/EditWaypointActivity.java
+++ b/main/src/cgeo/geocaching/EditWaypointActivity.java
@@ -439,7 +439,7 @@ public class EditWaypointActivity extends AbstractActionBarActivity implements C
                     }
                     Waypoint oldWaypoint = cache.getWaypointById(id);
                     if (cache.addOrChangeWaypoint(waypoint, true)) {
-                        DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+                        DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
                         if (!StaticMapsProvider.hasAllStaticMapsForWaypoint(geocode, waypoint)) {
                             StaticMapsProvider.removeWpStaticMaps(oldWaypoint, geocode);
                             if (Settings.isStoreOfflineWpMaps()) {
diff --git a/main/src/cgeo/geocaching/Geocache.java b/main/src/cgeo/geocaching/Geocache.java
index f3ff487..91ab6da 100644
--- a/main/src/cgeo/geocaching/Geocache.java
+++ b/main/src/cgeo/geocaching/Geocache.java
@@ -1325,7 +1325,7 @@ public class Geocache implements ICache, IWaypoint {
             final int index = getWaypointIndex(waypoint);
             waypoints.remove(index);
             DataStore.deleteWaypoint(waypoint.getId());
-            DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+            DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.CACHE));
             // Check status if Final is defined
             if (waypoint.isFinalWithCoords()) {
                 resetFinalDefined();
@@ -1345,7 +1345,7 @@ public class Geocache implements ICache, IWaypoint {
         final int index = getWaypointIndex(waypoint);
         waypoints.remove(index);
         DataStore.deleteWaypoint(waypoint.getId());
-        DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+        DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.CACHE));
         resetFinalDefined();
     }
 
@@ -1469,7 +1469,7 @@ public class Geocache implements ICache, IWaypoint {
 
     public void dropSynchronous() {
         DataStore.markDropped(Collections.singletonList(this));
-        DataStore.removeCache(getGeocode(), EnumSet.of(RemoveFlag.REMOVE_CACHE));
+        DataStore.removeCache(getGeocode(), EnumSet.of(RemoveFlag.CACHE));
     }
 
     public void checkFields() {
@@ -1525,7 +1525,7 @@ public class Geocache implements ICache, IWaypoint {
     }
 
     public void refreshSynchronous(final CancellableHandler handler) {
-        DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+        DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.CACHE));
         storeCache(null, geocode, listId, true, handler);
     }
 
@@ -1601,7 +1601,7 @@ public class Geocache implements ICache, IWaypoint {
             }
 
             cache.setListId(listId);
-            DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+            DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
 
             if (CancellableHandler.isCancelled(handler)) {
                 return;
@@ -1698,7 +1698,7 @@ public class Geocache implements ICache, IWaypoint {
      * @return
      */
     public boolean hasAttribute(final CacheAttribute attribute, final boolean yes) {
-        Geocache fullCache = DataStore.loadCache(getGeocode(), EnumSet.of(LoadFlag.LOAD_ATTRIBUTES));
+        Geocache fullCache = DataStore.loadCache(getGeocode(), EnumSet.of(LoadFlag.ATTRIBUTES));
         if (fullCache == null) {
             fullCache = this;
         }
diff --git a/main/src/cgeo/geocaching/SearchResult.java b/main/src/cgeo/geocaching/SearchResult.java
index 2e8a3f6..c56e29e 100644
--- a/main/src/cgeo/geocaching/SearchResult.java
+++ b/main/src/cgeo/geocaching/SearchResult.java
@@ -272,7 +272,7 @@ public class SearchResult implements Parcelable {
         for (Geocache geocache : caches) {
             addGeocode(geocache.getGeocode());
         }
-        DataStore.saveCaches(caches, EnumSet.of(SaveFlag.SAVE_CACHE));
+        DataStore.saveCaches(caches, EnumSet.of(SaveFlag.CACHE));
     }
 
     public boolean isEmpty() {
diff --git a/main/src/cgeo/geocaching/connector/ec/ECApi.java b/main/src/cgeo/geocaching/connector/ec/ECApi.java
index 702e557..5202184 100644
--- a/main/src/cgeo/geocaching/connector/ec/ECApi.java
+++ b/main/src/cgeo/geocaching/connector/ec/ECApi.java
@@ -205,7 +205,7 @@ public class ECApi {
             cache.setTerrain((float) response.getDouble("terrain"));
             cache.setSize(CacheSize.getById(response.getString("size")));
             cache.setFound(response.getInt("found") == 1);
-            DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_CACHE));
+            DataStore.saveCache(cache, EnumSet.of(SaveFlag.CACHE));
         } catch (final JSONException e) {
             Log.e("ECApi.parseCache", e);
             return null;
diff --git a/main/src/cgeo/geocaching/connector/gc/GCParser.java b/main/src/cgeo/geocaching/connector/gc/GCParser.java
index 8114d2a..93cb3a2 100644
--- a/main/src/cgeo/geocaching/connector/gc/GCParser.java
+++ b/main/src/cgeo/geocaching/connector/gc/GCParser.java
@@ -358,7 +358,7 @@ public abstract class GCParser {
 
         // save full detailed caches
         CancellableHandler.sendLoadProgressDetail(handler, R.string.cache_dialog_loading_details_status_cache);
-        DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+        DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
 
         // update progress message so user knows we're still working. This is more of a place holder than
         // actual indication of what the program is doing
diff --git a/main/src/cgeo/geocaching/connector/oc/OkapiClient.java b/main/src/cgeo/geocaching/connector/oc/OkapiClient.java
index 477830c..8bbbf18 100644
--- a/main/src/cgeo/geocaching/connector/oc/OkapiClient.java
+++ b/main/src/cgeo/geocaching/connector/oc/OkapiClient.java
@@ -297,9 +297,7 @@ final class OkapiClient {
             final JSONObject cachesResponse = response.getJSONObject("results");
             if (cachesResponse != null) {
                 final List<Geocache> caches = new ArrayList<Geocache>(cachesResponse.length());
-                @SuppressWarnings("unchecked")
-                final
-                Iterator<String> keys = cachesResponse.keys();
+                final Iterator<String> keys = cachesResponse.keys();
                 while (keys.hasNext()) {
                     final String key = keys.next();
                     final Geocache cache = parseSmallCache(cachesResponse.getJSONObject(key));
@@ -320,7 +318,7 @@ final class OkapiClient {
 
             parseCoreCache(response, cache);
 
-            DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_CACHE));
+            DataStore.saveCache(cache, EnumSet.of(SaveFlag.CACHE));
         } catch (final JSONException e) {
             Log.e("OkapiClient.parseSmallCache", e);
         }
@@ -401,7 +399,7 @@ final class OkapiClient {
 
             cache.setDetailedUpdatedNow();
             // save full detailed caches
-            DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+            DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
             DataStore.saveLogsWithoutTransaction(cache.getGeocode(), parseLogs(response.getJSONArray(CACHE_LATEST_LOGS)));
         } catch (final JSONException e) {
             Log.e("OkapiClient.parseCache", e);
diff --git a/main/src/cgeo/geocaching/enumerations/LoadFlags.java b/main/src/cgeo/geocaching/enumerations/LoadFlags.java
index fb894ac..c781f4b 100644
--- a/main/src/cgeo/geocaching/enumerations/LoadFlags.java
+++ b/main/src/cgeo/geocaching/enumerations/LoadFlags.java
@@ -8,39 +8,39 @@ import java.util.EnumSet;
 public interface LoadFlags {
 
     public enum LoadFlag {
-        LOAD_CACHE_BEFORE, // load from CacheCache
-        LOAD_CACHE_AFTER, // load from CacheCache
-        LOAD_DB_MINIMAL, // load minimal informations from DataBase
-        LOAD_ATTRIBUTES,
-        LOAD_WAYPOINTS,
-        LOAD_SPOILERS,
-        LOAD_LOGS,
-        LOAD_INVENTORY,
-        LOAD_OFFLINE_LOG
+        CACHE_BEFORE, // load from CacheCache
+        CACHE_AFTER, // load from CacheCache
+        DB_MINIMAL, // load minimal informations from DataBase
+        ATTRIBUTES,
+        WAYPOINTS,
+        SPOILERS,
+        LOGS,
+        INVENTORY,
+        OFFLINE_LOG
     }
 
     /** Retrieve cache from CacheCache only. Do not load from DB */
-    public final static EnumSet<LoadFlag> LOAD_CACHE_ONLY = EnumSet.of(LoadFlag.LOAD_CACHE_BEFORE);
+    public final static EnumSet<LoadFlag> LOAD_CACHE_ONLY = EnumSet.of(LoadFlag.CACHE_BEFORE);
     /** Retrieve cache from CacheCache first. If not found load from DB */
-    public final static EnumSet<LoadFlag> LOAD_CACHE_OR_DB = EnumSet.of(LoadFlag.LOAD_CACHE_BEFORE, LoadFlag.LOAD_DB_MINIMAL, LoadFlag.LOAD_OFFLINE_LOG);
+    public final static EnumSet<LoadFlag> LOAD_CACHE_OR_DB = EnumSet.of(LoadFlag.CACHE_BEFORE, LoadFlag.DB_MINIMAL, LoadFlag.OFFLINE_LOG);
     /** Retrieve cache (minimalistic information including waypoints) from DB first. If not found load from CacheCache */
-    public final static EnumSet<LoadFlag> LOAD_WAYPOINTS = EnumSet.of(LoadFlag.LOAD_CACHE_AFTER, LoadFlag.LOAD_DB_MINIMAL, LoadFlag.LOAD_WAYPOINTS, LoadFlag.LOAD_OFFLINE_LOG);
+    public final static EnumSet<LoadFlag> LOAD_WAYPOINTS = EnumSet.of(LoadFlag.CACHE_AFTER, LoadFlag.DB_MINIMAL, LoadFlag.WAYPOINTS, LoadFlag.OFFLINE_LOG);
     /** Retrieve cache (all stored informations) from DB only. Do not load from CacheCache */
-    public final static EnumSet<LoadFlag> LOAD_ALL_DB_ONLY = EnumSet.range(LoadFlag.LOAD_DB_MINIMAL, LoadFlag.LOAD_OFFLINE_LOG);
+    public final static EnumSet<LoadFlag> LOAD_ALL_DB_ONLY = EnumSet.range(LoadFlag.DB_MINIMAL, LoadFlag.OFFLINE_LOG);
 
     public enum SaveFlag {
-        SAVE_CACHE, // save only to CacheCache
-        SAVE_DB // include saving to CacheCache
+        CACHE, // save only to CacheCache
+        DB // include saving to CacheCache
     }
 
     public final static EnumSet<SaveFlag> SAVE_ALL = EnumSet.allOf(SaveFlag.class);
 
     public enum RemoveFlag {
-        REMOVE_CACHE, // save only to CacheCache
-        REMOVE_DB, // includes removing from CacheCache
-        REMOVE_OWN_WAYPOINTS_ONLY_FOR_TESTING // only to be used in unit testing (as we never delete own waypoints)
+        CACHE, // save only to CacheCache
+        DB, // includes removing from CacheCache
+        OWN_WAYPOINTS_ONLY_FOR_TESTING // only to be used in unit testing (as we never delete own waypoints)
     }
 
-    public final static EnumSet<RemoveFlag> REMOVE_ALL = EnumSet.of(RemoveFlag.REMOVE_CACHE, RemoveFlag.REMOVE_DB);
+    public final static EnumSet<RemoveFlag> REMOVE_ALL = EnumSet.of(RemoveFlag.CACHE, RemoveFlag.DB);
 
 }
\ No newline at end of file
diff --git a/main/src/cgeo/geocaching/files/GPXParser.java b/main/src/cgeo/geocaching/files/GPXParser.java
index f3cd326..d42c377 100644
--- a/main/src/cgeo/geocaching/files/GPXParser.java
+++ b/main/src/cgeo/geocaching/files/GPXParser.java
@@ -340,11 +340,11 @@ public abstract class GPXParser extends FileParser {
 
                     // finally store the cache in the database
                     result.add(geocode);
-                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+                    DataStore.saveCache(cache, EnumSet.of(SaveFlag.DB));
                     DataStore.saveLogsWithoutTransaction(cache.getGeocode(), logs);
 
                     // avoid the cachecache using lots of memory for caches which the user did not actually look at
-                    DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+                    DataStore.removeCache(geocode, EnumSet.of(RemoveFlag.CACHE));
                     showProgressMessage(progressHandler, progressStream.getProgress());
                 } else if (StringUtils.isNotBlank(cache.getName())
                         && StringUtils.containsIgnoreCase(type, "waypoint")) {
@@ -388,7 +388,7 @@ public abstract class GPXParser extends FileParser {
                         newPoints.add(waypoint);
                         Waypoint.mergeWayPoints(newPoints, mergedWayPoints, true);
                         cacheForWaypoint.setWaypoints(newPoints, false);
-                        DataStore.saveCache(cacheForWaypoint, EnumSet.of(SaveFlag.SAVE_DB));
+                        DataStore.saveCache(cacheForWaypoint, EnumSet.of(SaveFlag.DB));
                         showProgressMessage(progressHandler, progressStream.getProgress());
                     }
                 }
@@ -816,7 +816,7 @@ public abstract class GPXParser extends FileParser {
             progressStream = new ProgressInputStream(stream);
             BufferedReader reader = new BufferedReader(new InputStreamReader(progressStream, CharEncoding.UTF_8));
             Xml.parse(new InvalidXMLCharacterFilterReader(reader), root.getContentHandler());
-            return DataStore.loadCaches(result, EnumSet.of(LoadFlag.LOAD_DB_MINIMAL));
+            return DataStore.loadCaches(result, EnumSet.of(LoadFlag.DB_MINIMAL));
         } catch (final SAXException e) {
             throw new ParserException("Cannot parse .gpx file as GPX " + version + ": could not parse XML", e);
         }
diff --git a/main/src/cgeo/geocaching/maps/CGeoMap.java b/main/src/cgeo/geocaching/maps/CGeoMap.java
index 736b3fd..d0a9e5e 100644
--- a/main/src/cgeo/geocaching/maps/CGeoMap.java
+++ b/main/src/cgeo/geocaching/maps/CGeoMap.java
@@ -1317,7 +1317,7 @@ public class CGeoMap extends AbstractMap implements ViewFactory {
             final Set<String> filteredCodes = searchResult.getFilteredGeocodes();
             Log.d("Filtering out " + filteredCodes.size() + " caches: " + filteredCodes.toString());
             caches.removeAll(DataStore.loadCaches(filteredCodes, LoadFlags.LOAD_CACHE_ONLY));
-            DataStore.removeCaches(filteredCodes, EnumSet.of(RemoveFlag.REMOVE_CACHE));
+            DataStore.removeCaches(filteredCodes, EnumSet.of(RemoveFlag.CACHE));
             // new collection type needs to remove first to refresh
             caches.removeAll(result);
             caches.addAll(result);
diff --git a/main/src/cgeo/geocaching/settings/AbstractCheckCredentialsPreference.java b/main/src/cgeo/geocaching/settings/AbstractCheckCredentialsPreference.java
index b209a70..1a230c1 100644
--- a/main/src/cgeo/geocaching/settings/AbstractCheckCredentialsPreference.java
+++ b/main/src/cgeo/geocaching/settings/AbstractCheckCredentialsPreference.java
@@ -41,31 +41,31 @@ public abstract class AbstractCheckCredentialsPreference extends AbstractClickab
     protected abstract ImmutablePair<StatusCode, ? extends Drawable> login();
 
     private class LoginCheckClickListener implements OnPreferenceClickListener {
-        final private SettingsActivity activity;
+        final private SettingsActivity settingsActivity;
 
         LoginCheckClickListener(final SettingsActivity activity) {
-            this.activity = activity;
+            this.settingsActivity = activity;
         }
 
         @Override
         public boolean onPreferenceClick(Preference preference) {
-            final Resources res = activity.getResources();
+            final Resources res = settingsActivity.getResources();
             final ImmutablePair<String, String> credentials = getCredentials();
 
             // check credentials for validity
             if (StringUtils.isBlank(credentials.getLeft())
                     || StringUtils.isBlank(credentials.getRight())) {
-                ActivityMixin.showToast(activity, R.string.err_missing_auth);
+                ActivityMixin.showToast(settingsActivity, R.string.err_missing_auth);
                 return false;
             }
 
-            final ProgressDialog loginDialog = ProgressDialog.show(activity,
+            final ProgressDialog loginDialog = ProgressDialog.show(settingsActivity,
                     res.getString(R.string.init_login_popup),
                     res.getString(R.string.init_login_popup_working), true);
             loginDialog.setCancelable(false);
             Cookies.clearCookies();
 
-            AndroidObservable.bindActivity(activity, Async.start(new Func0<ImmutablePair<StatusCode, ? extends Drawable>>() {
+            AndroidObservable.bindActivity(settingsActivity, Async.start(new Func0<ImmutablePair<StatusCode, ? extends Drawable>>() {
                 @Override
                 public ImmutablePair<StatusCode, ? extends Drawable> call() {
                     return login();
@@ -75,16 +75,16 @@ public abstract class AbstractCheckCredentialsPreference extends AbstractClickab
                 public void call(final ImmutablePair<StatusCode, ? extends Drawable> loginInfo) {
                     loginDialog.dismiss();
                     if (loginInfo.getLeft() == StatusCode.NO_ERROR) {
-                        Dialogs.message(activity, R.string.init_login_popup, R.string.init_login_popup_ok, loginInfo.getRight());
+                        Dialogs.message(settingsActivity, R.string.init_login_popup, R.string.init_login_popup_ok, loginInfo.getRight());
                     } else {
-                        Dialogs.message(activity, R.string.init_login_popup,
+                        Dialogs.message(settingsActivity, R.string.init_login_popup,
                                 res.getString(R.string.init_login_popup_failed_reason)
                                         + " "
                                         + loginInfo.getLeft().getErrorString(res)
                                         + "."
                         );
                     }
-                    activity.initBasicMemberPreferences();
+                    settingsActivity.initBasicMemberPreferences();
                 }
             });