propertylist/Propertylist.java

   1
   2 //
   3 //  FIXME: replace Hashtable by Properties
   4 //
   5
   6 package org.de.metux.propertylist;
   7
   8 import java.io.*;
   9 import java.util.Enumeration;
  10 import java.util.Hashtable;
  11 import java.util.Properties;
  12
  13 import java.lang.NumberFormatException;
  14
  15 import org.de.metux.util.StrSplit;
  16 import org.de.metux.util.TextDB;
  17 import org.de.metux.util.UniqueNameList;
  18 import org.de.metux.util.LoadFile;
  19 import org.de.metux.util.StrUtil;
  20 import org.de.metux.util.CachedDatasource;
  21
  22 import java.net.URLEncoder;
  23
  24 import java.net.URL;
  25
  26 public class Propertylist implements IPropertylist
  27 {
  28     Properties db = new Properties();
  29     Properties cache = new Properties();
  30     IPostprocessor postprocessor;
  31
  32     public static Hashtable db_recycling = null;
  33     public static CachedDatasource datasource_cache = new CachedDatasource();
  34
  35     private class dbcache_ent
  36     {
  37         public Properties proplist;
  38         public String text;
  39     }
  40
  41     /* this method loads data from a hashtable into the propertysheet
  42        with low priority, means that existing fields are not touched.
  43
  44        the opposite would be high priority meaning existing fields
  45        will be overwritten.
  46     */
  47
  48     public void setPostprocessor(IPostprocessor p)
  49     {
  50         postprocessor = p;
  51     }
  52
  53     public void runPostprocessor()
  54         throws EIllegalValue
  55     {
  56         if (postprocessor==null)
  57             return;
  58
  59         /* run as long as it returns true */
  60         while(postprocessor.propertylist_postprocess((IPropertylist)this));
  61     }
  62
  63     /* get a really raw string, directly from database */
  64     public String db_get(String field)
  65     {
  66         return (String)db.get(field);
  67     }
  68
  69     public void loadProperties_sub(Properties pr)
  70     {
  71         for (Enumeration e = pr.keys(); e.hasMoreElements(); )
  72         {
  73             String key = (String) e.nextElement();
  74
  75             /* fields with !! always have precedence */
  76             if (key.startsWith("!!"))
  77                 db.put(key.substring(2),(String)pr.get(key));
  78
  79             /* fields with ++ are always added, not just overwritten */
  80             else if (key.startsWith("++"))
  81                 add(key.substring(2),(String)pr.get(key));
  82
  83             /* in this loading mode we do not overwrite existing fields */
  84             else if (!db.containsKey(key))
  85                 set(key,(String)pr.get(key));
  86         }
  87         cache.clear();
  88     }
  89
  90     public void loadProperties_top(Properties pr)
  91     {
  92         for (Enumeration e = pr.keys(); e.hasMoreElements(); )
  93         {
  94             String key = (String) e.nextElement();
  95             if (key.startsWith("!!"))
  96                 set(key.substring(2),(String)pr.get(key));
  97             else if (key.startsWith("++"))
  98                 add(key.substring(2),(String)pr.get(key));
  99             else
 100                 set(key,(String)pr.get(key));
 101         }
 102     }
 103
 104     public void remove ( String key )
 105     {
 106         db.remove(key);
 107         cache.clear();
 108     }
 109
 110     public void set ( String key, String value )
 111     {
 112         db.put(key,value);
 113         cache.clear();
 114     }
 115
 116     public void add ( String key, String value )
 117     {
 118         String got;
 119         if ((key==null)||(value==null)) return;
 120
 121         if ((got=db_get(key))!=null)
 122             db.put(key,got+"\n"+value);
 123         else
 124             db.put(key,value);
 125     }
 126
 127     // can be overwritten, ie for namespace handling, hierachies, etc
 128     public String get_raw(String name)
 129         throws EIllegalValue
 130     {
 131         if (name.startsWith(":URLENCODE:"))
 132         {
 133             name = name.substring(11);
 134             return URLEncoder.encode(get_str(name));
 135         }
 136
 137         return db_get(name);
 138     }
 139
 140     public String get_str(String name)
 141         throws EIllegalValue
 142     {
 143         return get_str_rec(name,100);
 144     }
 145
 146     public String[] get_list(String name)
 147         throws EIllegalValue
 148     {
 149         return StrSplit.split(get_str(name));
 150     }
 151
 152     /* can be overwritten in order to handle special things like exec()
 153        returns null if nothing happened */
 154     public String handle_special_str(String key)
 155     {
 156         return null;
 157     }
 158
 159     public boolean get_bool(String name, boolean def)
 160     {
 161         try
 162         {
 163             return get_bool(name);
 164         }
 165         catch (EIllegalValue e)
 166         {
 167             return def;
 168         }
 169     }
 170
 171     public boolean get_bool(String name) throws EIllegalValue
 172     {
 173         String val=get_str(name);
 174         try
 175         {
 176             return StrUtil.toBool(val);
 177         }
 178         catch (NumberFormatException e)
 179         {
 180             throw new EIllegalValue(name,val);
 181         }
 182     }
 183
 184     private final String get_str_rec(String key, int depth)
 185         throws EIllegalValue
 186     {
 187         if (depth<1)
 188             throw new EInfiniteRecursion(key,get_raw(key));
 189
 190         /* if we someday want to add special vars/commands, this
 191            would probably be the right point */
 192
 193         String value;
 194                 boolean notnull = false;
 195                 boolean notempty = false;
 196
 197                 /* handle subclass-defined specials */
 198         if ((value=handle_special_str(key))!=null)
 199             return value;
 200
 201                 /* -- parse special modifiers -- */
 202                 for (boolean parsing=true; parsing;)
 203                 {
 204                         if (key.startsWith("!notnull!"))
 205                         {
 206                                 notnull = true;
 207                                 key = key.substring(9);
 208                         }
 209                         else if (key.startsWith("!notempty!"))
 210                         {
 211                                 notempty = true;
 212                                 key = key.substring(10);
 213                         }
 214                         else
 215                                 parsing = false;
 216                 }
 217
 218                 if ((value=get_raw(key))==null)
 219                 {
 220                         if (notnull)
 221                                 throw new EVariableNull(key,value);
 222                         else
 223                                 return "";
 224                 }
 225
 226         /* --- now replace variables ---  */
 227         int start, end;
 228
 229         while ((start=value.indexOf("$("))!=-1) /* scan for $( */
 230         {
 231             if ((end=value.indexOf(')', start+2))!=-1)
 232             {
 233                 String name = value.substring(start+2,end);
 234                 String newval =
 235                     value.substring(0,start)+
 236                     get_str_rec(name,depth-1)+
 237                     value.substring(end+1);
 238
 239                 value = newval;
 240             }
 241             else
 242                 throw new EVariableParseError(key,value);
 243         }
 244
 245                 if (value.equals("") && notempty)
 246                         throw new EVariableEmpty(key,value);
 247
 248         return value;
 249     }
 250
 251     public String dump()
 252     {
 253         String res = "";
 254         for (Enumeration e = db.keys(); e.hasMoreElements(); )
 255         {
 256             String key = (String) e.nextElement();
 257             res += key+"=\""+db_get(key)+"\"\n";
 258         }
 259         return res;
 260     }
 261
 262     public boolean load_content(String field, File filename, boolean strip_comments)
 263     {
 264         String text = datasource_cache.loadContent(filename,strip_comments);
 265
 266         if (text==null)
 267             return false;
 268         set(field,text);
 269         return true;
 270     }
 271
 272     public boolean load_content(String field, URL url, boolean strip_comments)
 273     {
 274         String text = datasource_cache.loadContent(url,strip_comments);
 275         if (text==null)
 276             return false;
 277
 278         set(field,text);
 279         return true;
 280     }
 281
 282     public Enumeration propertyNames()
 283     {
 284         return db.keys();
 285     }
 286
 287     public IPropertylist clone()
 288     {
 289         Propertylist pr = new Propertylist();
 290         pr.db = (Properties)db.clone();
 291
 292         // copy the database
 293         for (Enumeration keys = db.keys(); keys.hasMoreElements(); )
 294         {
 295             String k = (String)keys.nextElement();
 296             pr.set(k,db_get(k));
 297         }
 298         return pr;
 299     }
 300
 301     public String toString()
 302     {
 303         String str = "[PROPERTYLIST]\n";
 304         for (Enumeration keys = db.keys(); keys.hasMoreElements(); )
 305         {
 306             String k = (String)keys.nextElement();
 307             str += k+"=\""+db_get(k)+"\"\n";
 308         }
 309         return str;
 310     }
 311 }