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