OptionsMap.java
001 /*
002  *  Copyright (c) 1995-2012, The University of Sheffield. See the file
003  *  COPYRIGHT.txt in the software or at http://gate.ac.uk/gate/COPYRIGHT.txt
004  *
005  *  This file is part of GATE (see http://gate.ac.uk/), and is free
006  *  software, licenced under the GNU Library General Public License,
007  *  Version 2, June 1991 (in the distribution as file licence.html,
008  *  and also available at http://gate.ac.uk/gate/licence.html).
009  *
010  *  Valentin Tablan, 09/11/2001
011  *
012  *  $Id: OptionsMap.java 17600 2014-03-08 18:47:11Z markagreenwood $
013  */
014 package gate.util;
015 
016 import java.awt.Font;
017 import java.awt.font.TextAttribute;
018 import java.io.File;
019 import java.io.Serializable;
020 import java.util.HashMap;
021 import java.util.LinkedHashSet;
022 import java.util.Map;
023 import java.util.StringTokenizer;
024 import java.util.TreeMap;
025 
026 /**
027  * A map that stores values as strings and provides support for converting some
028  * frequently used types to and from string.<br>
029  * Not very efficient as there is a lot of conversions from/to String.
030  * The conversion could happen only when loading/saving from/to a file.
031  */
032 public class OptionsMap extends TreeMap<Object, Object> {
033 
034   private static final long serialVersionUID = 1005431810071035036L;
035 
036   /**
037    * Converts the value to string using {@link Strings#toString(Object)}
038    * method and then stores it.
039    * There is get methods for values that are a String, an Integer, a Boolean,
040    * a Font, a List of String and a Map of String*String.
041    */
042   @Override
043   public Object put(Object key, Object value) {
044     if(value instanceof Font){
045       Font font = (Font)value;
046       String family = font.getFamily();
047       int size = font.getSize();
048       boolean italic = font.isItalic();
049       boolean bold = font.isBold();
050       value = family + "#" + size + "#" + italic + "#" + bold;
051     }
052     return super.put(key.toString(), Strings.toString(value));
053   }
054 
055   public Object put(Object key, LinkedHashSet<String> value) {
056     return super.put(key.toString(), Strings.toString(value));
057   }
058 
059   public Object put(Object key, Map<String, String> value) {
060     return super.put(key.toString(), Strings.toString(value));
061   }
062 
063   /**
064    * If the object stored under key is an Integer then returns its value
065    * otherwise returns null.
066    @param key key associated to the value to retrieve
067    @return the associated integer
068    */
069   public Integer getInt(Object key) {
070     try {
071       return Integer.decode((Stringget(key));
072     catch (Exception e) {
073       return null;
074     }
075   }
076   
077   public Integer getInt(Object key, Integer defaultValue) {
078     Integer value = getInt(key);
079     
080     return (value != null ? value : defaultValue);
081   }
082   
083   public File getFile(Object key) {
084     try {
085       return new File((String)get(key));
086     }
087     catch (Exception e) {
088       return null;
089     }
090   }
091 
092   /**
093    * If the object stored under key is an Double then returns its value
094    * otherwise returns null.
095    @param key key associated to the value to retrieve
096    @return the associated Double
097    */
098   public Double getDouble(Object key) {
099     try {
100       return Double.valueOf((Stringget(key));
101     catch (Exception e) {
102       return null;
103     }
104   }
105 
106   /**
107    * If the object stored under key is a Boolean then returns its value
108    * otherwise returns false.
109    @param key key associated to the value to retrieve
110    @return the associated boolean
111    */
112   public Boolean getBoolean(Object key) {
113     try {
114       return Boolean.valueOf((Stringget(key));
115     catch (Exception e) {
116       return false;
117     }
118   }
119   
120   public Boolean getBoolean(Object key, Boolean defaultValue) {
121     try {
122       if(containsKey(key)) return Boolean.valueOf((String)get(key));
123     catch(Exception e) {
124 
125     }
126 
127     return defaultValue;
128   }
129 
130   /**
131    * If the object stored under key is a String then returns its value
132    * otherwise returns null.
133    @param key key associated to the value to retrieve
134    @return the associated string
135    */
136   public String getString(Object key) {
137     try {
138       return (Stringget(key);
139     catch (Exception e) {
140       return null;
141     }
142   }
143 
144   /**
145    * If the object stored under key is a Font then returns its value
146    * otherwise returns null.
147    @param key key associated to the value to retrieve
148    @return the associated font
149    */
150   public Font getFont(Object key) {
151     try {
152       String stringValue = (Stringget(key);
153       if (stringValue == null) { return null}
154       StringTokenizer strTok = new StringTokenizer(stringValue, "#"false);
155       String family = strTok.nextToken();
156       int size = Integer.parseInt(strTok.nextToken());
157       boolean italic = Boolean.valueOf(strTok.nextToken());
158       boolean bold = Boolean.valueOf(strTok.nextToken());
159       HashMap<TextAttribute, Serializable> fontAttrs =
160         new HashMap<TextAttribute, Serializable>();
161       fontAttrs.put(TextAttribute.FAMILY, family);
162       fontAttrs.put(TextAttribute.SIZE, (floatsize);
163       if(boldfontAttrs.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
164       else fontAttrs.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
165       if(italicfontAttrs.put(
166         TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
167       else fontAttrs.put(TextAttribute.POSTURE, TextAttribute.POSTURE_REGULAR);
168       return new Font(fontAttrs);
169     catch (Exception e) {
170       return null;
171     }
172   }
173 
174   /**
175    * If the object stored under key is a set then returns its value
176    * otherwise returns an empty set.
177    *
178    @param key key associated to the value to retrieve
179    @return the associated linked hash set
180    */
181   public LinkedHashSet<String> getSet(Object key) {
182     return Strings.toSet((Stringget(key)", ");
183   }
184 
185 
186   /**
187    * If the object stored under key is a map then returns its value
188    * otherwise returns an empty map.
189    *
190    @param key key associated to the value to retrieve
191    @return the associated map
192    */
193   public Map<String, String> getMap(Object key) {
194       return Strings.toMap((Stringget(key));
195   }
196   
197   /**
198    * Returns a String based view of the data. All the keys and values
199    * are stored as strings in the underlying map, but because we want to
200    * allow the addition of Object, which is then converted to a String,
201    * we aren't ourselves typed as String to String.
202    */
203   public Map<String, String> getStringMap() {
204     Map<String, String> data = new HashMap<String, String>();
205     for(Map.Entry<Object, Object> entry : this.entrySet()) {
206       data.put((String)entry.getKey()(String)entry.getValue());
207     }
208     return data;
209   }
210 }