    001// License: GPL. For details, see LICENSE file.
    002package org.openstreetmap.josm.plugins.streetside.cache;
    003
    004import java.io.File;
    005import java.io.IOException;
    006import java.io.Serializable;
    007
    008import javax.swing.ImageIcon;
    009
    010import org.apache.commons.jcs.access.CacheAccess;
    011import org.apache.commons.jcs.engine.behavior.IElementAttributes;
    012
    013import org.openstreetmap.josm.Main;
    014import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
    015import org.openstreetmap.josm.data.cache.JCSCacheManager;
    016import org.openstreetmap.josm.plugins.streetside.model.UserProfile;
    017import org.openstreetmap.josm.tools.Logging;
    018
    019public final class Caches {
    020
    021        private Caches() {
    022                // Private constructor to avoid instantiation
    023        }
    024
    025        public static File getCacheDirectory() {
    026                final File f = new File(Main.pref.getPluginsDirectory().getPath() + "/MicrosoftStreetside/cache");
    027                if (!f.exists()) {
    028                        f.mkdirs();
    029                }
    030                return f;
    031        }
    032
    033        public abstract static class CacheProxy<K, V extends Serializable> {
    034                private final CacheAccess<K, V> cache;
    035
    036                public CacheProxy() {
    037                        CacheAccess<K, V> c;
    038                        try {
    039                                c = createNewCache();
    040                        } catch (IOException e) {
    041                                Logging.log(Logging.LEVEL_WARN, "Could not initialize cache for " + getClass().getName(), e);
    042                                c = null;
    043                        }
    044                        cache = c;
    045                }
    046
    047                protected abstract CacheAccess<K, V> createNewCache() throws IOException;
    048
    049                public V get(final K key) {
    050                        return cache == null ? null : cache.get(key);
    051                }
    052
    053                public void put(final K key, final V value) {
    054                        if (cache != null) {
    055                                cache.put(key, value);
    056                        }
    057                }
    058        }
    059
    060        public static class ImageCache {
    061                private static ImageCache instance;
    062                private final CacheAccess<String, BufferedImageCacheEntry> cache;
    063
    064                public ImageCache() {
    065                        CacheAccess<String, BufferedImageCacheEntry> c;
    066                        try {
    067                                c = JCSCacheManager.getCache("streetside", 10, 10000, Caches.getCacheDirectory().getPath());
    068                        } catch (Exception e) {
    069                                Logging.log(Logging.LEVEL_WARN, "Could not initialize the Streetside image cache.", e);
    070                                c = null;
    071                        }
    072                        cache = c;
    073                }
    074
    075                public CacheAccess<String, BufferedImageCacheEntry> getCache() {
    076                        return cache;
    077                }
    078
    079                public static ImageCache getInstance() {
    080                        synchronized (ImageCache.class) {
    081                                if (ImageCache.instance == null) {
    082                                        ImageCache.instance = new ImageCache();
    083                                }
    084                                return ImageCache.instance;
    085                        }
    086                }
    087        }
    088
    089        public static class CubemapCache {
    090                private static CubemapCache instance;
    091                private final CacheAccess<String, BufferedImageCacheEntry> cache;
    092
    093                public CubemapCache() {
    094                        CacheAccess<String, BufferedImageCacheEntry> c;
    095                        try {
    096                                c = JCSCacheManager.getCache("streetside", 10, 10000, Caches.getCacheDirectory().getPath());
    097                        } catch (Exception e) {
    098                                Logging.log(Logging.LEVEL_WARN, "Could not initialize the Streetside cubemap cache.", e);
    099                                c = null;
    100                        }
    101                        cache = c;
    102                }
    103
    104                public CacheAccess<String, BufferedImageCacheEntry> getCache() {
    105                        return cache;
    106                }
    107
    108                public static CubemapCache getInstance() {
    109                        synchronized (CubemapCache.class) {
    110                                if (CubemapCache.instance == null) {
    111                                        CubemapCache.instance = new CubemapCache();
    112                                }
    113                                return CubemapCache.instance;
    114                        }
    115                }
    116        }
    117
    118        public static class MapObjectIconCache extends CacheProxy<String, ImageIcon> {
    119                private static CacheProxy<String, ImageIcon> instance;
    120
    121                public static CacheProxy<String, ImageIcon> getInstance() {
    122                        synchronized (MapObjectIconCache.class) {
    123                                if (MapObjectIconCache.instance == null) {
    124                                        MapObjectIconCache.instance = new MapObjectIconCache();
    125                                }
    126                                return MapObjectIconCache.instance;
    127                        }
    128                }
    129
    130                @Override
    131                protected CacheAccess<String, ImageIcon> createNewCache() throws IOException {
    132                        return JCSCacheManager.getCache("streetsideObjectIcons", 100, 1000, Caches.getCacheDirectory().getPath());
    133                }
    134        }
    135
    136        public static class UserProfileCache extends CacheProxy<String, UserProfile> {
    137                private static CacheProxy<String, UserProfile> instance;
    138
    139                public static CacheProxy<String, UserProfile> getInstance() {
    140                        synchronized (UserProfileCache.class) {
    141                                if (UserProfileCache.instance == null) {
    142                                        UserProfileCache.instance = new UserProfileCache();
    143                                }
    144                                return UserProfileCache.instance;
    145                        }
    146                }
    147
    148                @Override
    149                protected CacheAccess<String, UserProfile> createNewCache() throws IOException {
    150                        CacheAccess<String, UserProfile> cache =
    151                                        JCSCacheManager.getCache("userProfile", 100, 1000, Caches.getCacheDirectory().getPath());
    152                        IElementAttributes atts = cache.getDefaultElementAttributes();
    153                        atts.setMaxLife(604_800_000); // Sets lifetime to 7 days (604800000=1000*60*60*24*7)
    154                        cache.setDefaultElementAttributes(atts);
    155                        return cache;
    156                }
    157        }
    158}