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