JAL-3161 limit tooltip and status updates to visible columns
[jalview.git] / src / jalview / io / cache / AppCache.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.io.cache;
22
23 import jalview.bin.Cache;
24
25 import java.util.Hashtable;
26 import java.util.LinkedHashSet;
27
28 /**
29  * A singleton class used for querying and persisting cache items.
30  * 
31  * @author tcnofoegbu
32  *
33  */
34 public class AppCache
35 {
36   public static final String DEFAULT_LIMIT = "99";
37
38   public static final String CACHE_DELIMITER = ";";
39
40   private static AppCache instance = null;
41
42   private static final String DEFAULT_LIMIT_KEY = ".DEFAULT_LIMIT";
43
44   private Hashtable<String, LinkedHashSet<String>> cacheItems;
45
46   private AppCache()
47   {
48     cacheItems = new Hashtable<String, LinkedHashSet<String>>();
49   }
50
51   /**
52    * Method to obtain all the cache items for a given cache key
53    * 
54    * @param cacheKey
55    * @return
56    */
57   public LinkedHashSet<String> getAllCachedItemsFor(String cacheKey)
58   {
59     LinkedHashSet<String> foundCache = cacheItems.get(cacheKey);
60     if (foundCache == null)
61     {
62       foundCache = new LinkedHashSet<String>();
63       cacheItems.put(cacheKey, foundCache);
64     }
65     return foundCache;
66   }
67
68   /**
69    * Returns a singleton instance of AppCache
70    * 
71    * @return
72    */
73   public static AppCache getInstance()
74   {
75     if (instance == null)
76     {
77       instance = new AppCache();
78     }
79     return instance;
80   }
81
82   /**
83    * Method for persisting cache items for a given cache key
84    * 
85    * @param cacheKey
86    */
87   public void persistCache(String cacheKey)
88   {
89     LinkedHashSet<String> foundCacheItems = getAllCachedItemsFor(cacheKey);
90     StringBuffer delimitedCacheBuf = new StringBuffer();
91     for (String cacheItem : foundCacheItems)
92     {
93       delimitedCacheBuf.append(CACHE_DELIMITER).append(cacheItem);
94     }
95     if (delimitedCacheBuf.length() > 0)
96     {
97       delimitedCacheBuf.deleteCharAt(0);
98     }
99     String delimitedCacheString = delimitedCacheBuf.toString();
100
101     Cache.setProperty(cacheKey, delimitedCacheString);
102   }
103
104   /**
105    * Method for deleting cached items for a given cache key
106    * 
107    * @param cacheKey
108    *          the cache key
109    */
110   public void deleteCacheItems(String cacheKey)
111   {
112     cacheItems.put(cacheKey, new LinkedHashSet<String>());
113     persistCache(cacheKey);
114   }
115
116   /**
117    * Method for obtaining the preset maximum cache limit for a given cache key
118    * 
119    * @param cacheKey
120    *          the cache key
121    * @return the max number of items that could be cached
122    */
123   public String getCacheLimit(String cacheKey)
124   {
125     String uniqueKey = cacheKey + DEFAULT_LIMIT_KEY;
126     return Cache.getDefault(uniqueKey, DEFAULT_LIMIT);
127   }
128
129   /**
130    * Method for updating the preset maximum cache limit for a given cache key
131    * 
132    * @param cacheKey
133    *          the cache key
134    * @param newLimit
135    *          the max number of items that could be cached for the given cache
136    *          key
137    * @return
138    */
139   public int updateCacheLimit(String cacheKey, int newUserLimit)
140   {
141     String newLimit = String.valueOf(newUserLimit);
142     String uniqueKey = cacheKey + DEFAULT_LIMIT_KEY;
143     String formerLimit = getCacheLimit(cacheKey);
144     if (newLimit != null && !newLimit.isEmpty()
145             && !formerLimit.equals(newLimit))
146     {
147       Cache.setProperty(uniqueKey, newLimit);
148       formerLimit = newLimit;
149     }
150     return Integer.valueOf(formerLimit);
151   }
152
153   /**
154    * Method for inserting cache items for given cache key into the cache data
155    * structure
156    * 
157    * @param cacheKey
158    *          the cache key
159    * @param cacheItems
160    *          the items to add to the cache
161    */
162   public void putCache(String cacheKey, LinkedHashSet<String> newCacheItems)
163   {
164     cacheItems.put(cacheKey, newCacheItems);
165   }
166
167 }