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