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     @Deprecated
  71     public void loadHash_sub(Hashtable h)
  72     {
  73         for (Enumeration e = h.keys(); e.hasMoreElements(); )
  74         {
  75             String key = (String) e.nextElement();
  76
  77             /* fields with !! always have precedence */
  78             if (key.startsWith("!!"))
  79                 db.put(key.substring(2),(String)h.get(key));
  80
  81             /* fields with ++ are always added, not just overwritten */
  82             else if (key.startsWith("++"))
  83                 add(key.substring(2),(String)h.get(key));
  84
  85             /* in this loading mode we do not overwrite existing fields */
  86             else if (!db.containsKey(key))
  87                 set(key,(String)h.get(key));
  88         }
  89         cache.clear();
  90     }
  91
  92     public void loadProperties_sub(Properties pr)
  93     {
  94         for (Enumeration e = pr.keys(); e.hasMoreElements(); )
  95         {
  96             String key = (String) e.nextElement();
  97
  98             /* fields with !! always have precedence */
  99             if (key.startsWith("!!"))
 100                 db.put(key.substring(2),(String)pr.get(key));
 101
 102             /* fields with ++ are always added, not just overwritten */
 103             else if (key.startsWith("++"))
 104                 add(key.substring(2),(String)pr.get(key));
 105
 106             /* in this loading mode we do not overwrite existing fields */
 107             else if (!db.containsKey(key))
 108                 set(key,(String)pr.get(key));
 109         }
 110         cache.clear();
 111     }
 112
 113     @Deprecated
 114     public void loadHash_top(Hashtable h)
 115     {
 116         for (Enumeration e = h.keys(); e.hasMoreElements(); )
 117         {
 118             String key = (String) e.nextElement();
 119             if (key.startsWith("!!"))
 120                 set(key.substring(2),(String)h.get(key));
 121             else if (key.startsWith("++"))
 122                 add(key.substring(2),(String)h.get(key));
 123             else
 124                 set(key,(String)h.get(key));
 125         }
 126     }
 127
 128     public void loadProperties_top(Properties pr)
 129     {
 130         for (Enumeration e = pr.keys(); e.hasMoreElements(); )
 131         {
 132             String key = (String) e.nextElement();
 133             if (key.startsWith("!!"))
 134                 set(key.substring(2),(String)pr.get(key));
 135             else if (key.startsWith("++"))
 136                 add(key.substring(2),(String)pr.get(key));
 137             else
 138                 set(key,(String)pr.get(key));
 139         }
 140     }
 141
 142     private Properties _load_properties(String filename)
 143     {
 144         if (enable_datasource_cache)
 145         {
 146             if (db_recycling==null)
 147                 db_recycling = new Hashtable();
 148
 149             dbcache_ent ent = (dbcache_ent)db_recycling.get(filename);
 150             if (ent!=null)
 151             {
 152 //              System.err.println("Found in cache: "+filename);
 153                 return ent.proplist;
 154             }
 155
 156             ent = new dbcache_ent();
 157             ent.proplist = new Properties();
 158             if (!TextDB.LoadIntoHashtable(filename,ent.proplist))
 159             {
 160 //              System.err.println("Could not load: "+filename);
 161                 ent.proplist = null;
 162             }
 163 //          else
 164 //              System.err.println("Loaded: "+filename);
 165
 166             db_recycling.put(filename,ent);
 167             return ent.proplist;
 168         }
 169         else
 170         {
 171             Properties pr = new Properties();
 172             if (!TextDB.LoadIntoHashtable(filename,pr))
 173                 return null;
 174             else
 175                 return pr;
 176         }
 177     }
 178
 179     public boolean loadTextDB_sub(String filename)
 180     {
 181         Properties pr = _load_properties(filename);
 182         if (pr==null)
 183         {
 184 //          System.err.println("Couldnt load properties from: "+filename);
 185             return false;
 186         }
 187         loadHash_sub(pr);
 188         return true;
 189     }
 190
 191     public boolean loadTextDB_top(File filename)
 192     {
 193         return loadTextDB_top(filename.toString());
 194     }
 195
 196     public boolean loadTextDB_top(String filename)
 197     {
 198         Properties pr = _load_properties(filename);
 199
 200         if (pr==null)
 201             return false;
 202
 203         loadHash_top(pr);
 204         return true;
 205     }
 206
 207     public void remove ( String key )
 208     {
 209         db.remove(key);
 210         cache.clear();
 211     }
 212
 213     public void set ( String key, String value )
 214     {
 215         db.put(key,value);
 216         cache.clear();
 217     }
 218
 219     public void add ( String key, String value )
 220     {
 221         String got;
 222         if ((key==null)||(value==null)) return;
 223
 224         if ((got=db_get(key))!=null)
 225             db.put(key,got+"\n"+value);
 226         else
 227             db.put(key,value);
 228     }
 229
 230     // can be overwritten, ie for namespace handling, hierachies, etc
 231     public String get_raw(String name)
 232         throws EIllegalValue
 233     {
 234         if (name.startsWith(":URLENCODE:"))
 235         {
 236             name = name.substring(11);
 237             return URLEncoder.encode(get_str(name));
 238         }
 239
 240         return db_get(name);
 241     }
 242
 243     public String get_str(String name)
 244         throws EIllegalValue
 245     {
 246         return get_str_rec(name,100);
 247     }
 248
 249     public String[] get_list(String name)
 250         throws EIllegalValue
 251     {
 252         return StrSplit.split(get_str(name));
 253     }
 254
 255     /* can be overwritten in order to handle special things like exec()
 256        returns null if nothing happened */
 257     public String handle_special_str(String key)
 258     {
 259         return null;
 260     }
 261
 262     public boolean get_bool(String name, boolean def)
 263     {
 264         try
 265         {
 266             return get_bool(name);
 267         }
 268         catch (EIllegalValue e)
 269         {
 270             return def;
 271         }
 272     }
 273
 274     public boolean get_bool(String name) throws EIllegalValue
 275     {
 276         String val=get_str(name);
 277         try
 278         {
 279             return StrUtil.toBool(val);
 280         }
 281         catch (NumberFormatException e)
 282         {
 283             throw new EIllegalValue(name,val);
 284         }
 285     }
 286
 287     private final String get_str_rec(String key, int depth)
 288         throws EIllegalValue
 289     {
 290         if (depth<1)
 291             throw new EInfiniteRecursion(key,get_raw(key));
 292
 293         /* if we someday want to add special vars/commands, this
 294            would probably be the right point */
 295
 296         String value;
 297                 boolean notnull = false;
 298                 boolean notempty = false;
 299
 300                 /* handle subclass-defined specials */
 301         if ((value=handle_special_str(key))!=null)
 302             return value;
 303
 304                 /* -- parse special modifiers -- */
 305                 for (boolean parsing=true; parsing;)
 306                 {
 307                         if (key.startsWith("!notnull!"))
 308                         {
 309                                 notnull = true;
 310                                 key = key.substring(9);
 311                         }
 312                         else if (key.startsWith("!notempty!"))
 313                         {
 314                                 notempty = true;
 315                                 key = key.substring(10);
 316                         }
 317                         else
 318                                 parsing = false;
 319                 }
 320
 321                 if ((value=get_raw(key))==null)
 322                 {
 323                         if (notnull)
 324                                 throw new EVariableNull(key,value);
 325                         else
 326                                 return "";
 327                 }
 328
 329         /* --- now replace variables ---  */
 330         int start, end;
 331
 332         while ((start=value.indexOf("$("))!=-1) /* scan for $( */
 333         {
 334             if ((end=value.indexOf(')', start+2))!=-1)
 335             {
 336                 String name = value.substring(start+2,end);
 337                 String newval =
 338                     value.substring(0,start)+
 339                     get_str_rec(name,depth-1)+
 340                     value.substring(end+1);
 341
 342                 value = newval;
 343             }
 344             else
 345                 throw new EVariableParseError(key,value);
 346         }
 347
 348                 if (value.equals("") && notempty)
 349                         throw new EVariableEmpty(key,value);
 350
 351         return value;
 352     }
 353
 354     public String dump()
 355     {
 356         String res = "";
 357         for (Enumeration e = db.keys(); e.hasMoreElements(); )
 358         {
 359             String key = (String) e.nextElement();
 360             res += key+"=\""+db_get(key)+"\"\n";
 361         }
 362         return res;
 363     }
 364
 365     public boolean load_content(String field, File filename, boolean strip_comments)
 366     {
 367         String text = datasource_cache.loadContent(filename,strip_comments);
 368
 369         if (text==null)
 370             return false;
 371         set(field,text);
 372         return true;
 373     }
 374
 375     public boolean load_content(String field, URL url, boolean strip_comments)
 376     {
 377         String text = datasource_cache.loadContent(url,strip_comments);
 378         if (text==null)
 379             return false;
 380
 381         set(field,text);
 382         return true;
 383     }
 384
 385     public Enumeration propertyNames()
 386     {
 387         return db.keys();
 388     }
 389
 390     public IPropertylist clone()
 391     {
 392         Propertylist pr = new Propertylist();
 393         pr.db = (Properties)db.clone();
 394
 395         // copy the database
 396         for (Enumeration keys = db.keys(); keys.hasMoreElements(); )
 397         {
 398             String k = (String)keys.nextElement();
 399             pr.set(k,db_get(k));
 400         }
 401         return pr;
 402     }
 403
 404     public String toString()
 405     {
 406         String str = "[PROPERTYLIST]\n";
 407         for (Enumeration keys = db.keys(); keys.hasMoreElements(); )
 408         {
 409             String k = (String)keys.nextElement();
 410             str += k+"=\""+db_get(k)+"\"\n";
 411         }
 412         return str;
 413     }
 414 }