Source code: Freenet/Params.java

   package Freenet;
   
   import Freenet.support.*;
   import java.util.*;
   import java.io.*;
   
   /**
    * Stores Freenet parameters
    **/
  public class Params
  {
      Hashtable params = new Hashtable();
      Vector argVector = new Vector();
      private Properties props = new Properties();
      private String savedOption = null;
      private boolean noMoreOptions = false;
  
  
      public static void main(String[] args)
      {
    try {
        Params p = new Params(".freenetrc", args);
        System.out.println("Params: " + p.params);
        System.out.println("Args: " + p.argVector);
    }
    catch (IOException e) {
        System.out.println ("Error reading .freenetrc: " + e);
    }
      }
  
      public Params() { }
      
      public Params(String filename) throws FileNotFoundException
      {
    this(ArrayFactory.makeArray(filename), null);
      }
  
      public Params(String[] args)
      {
    this((String[]) null, args);
      }
  
      public Params(String filename, String[] args) throws FileNotFoundException
      {
    this(ArrayFactory.makeArray(filename), args);
      }
  
  
      /**
       * Read in Freenet parameters
       * 
       * Really, this is kind of a hack and needs proper semantic option
       * handling to distinguish between those that take values and
       * those that don't.
       *
       **/
      public Params(String[] files, String[] args)
      {
    super();
  
    // read params from files
    if (files != null) {
        for (int x = 0; x < files.length; x++) {
      if (files[x] != null) {
          try {
        Logger.log("Params.java", "Reading config file " + files[x], Logger.MINOR);
        readParams(files[x]);
          }
          catch (FileNotFoundException e) {
        Logger.log("Params.java", "Couldn't load config file " + files[x], Logger.MINOR);
          }
      }
        }
    }
  
    // read params from command line (overrides file)
    if (args != null) {
        for (int x = 0; x < args.length; x++) {
      if (args[x] != null) {
          if (isOption (args[x])) {
        // process previous option, if any
        if (savedOption != null) {
            setParam (savedOption, "");
        }
  
        // save for next iteration
        if (!args[x].equals ("--")) {
            savedOption = args[x].substring(1);
        }
        else {
            noMoreOptions = true;
            savedOption = null;
        }
          }
          else {
        if (savedOption != null) {
            // store value for previous option
            setParam (savedOption, args[x]);
        }
       else {
           // store command argument
           argVector.addElement (args[x]);
       }
       savedOption = null;
         }
     }
       }
 
       // process last option, if any
       if (savedOption != null)
     setParam (savedOption, "");
   }
     }
 
   public void readParams(String filename) throws FileNotFoundException
   {
     FileInputStream in=new FileInputStream(filename);
 
     try
     {
       props.load(in);
     }
     catch(IOException e)
     {
       Logger.log("Params.java","Could not read config file",Logger.ERROR);
       return;
     }
     Enumeration iterator=props.propertyNames();
     while(iterator.hasMoreElements())
     {
       String name=(String)iterator.nextElement();
       params.put(name.toLowerCase(), props.getProperty(name));
     }
   }
 
   public void setParam(String name, String value)
   {
       Logger.log("Params.java", "set \""+name+"\" to \""+value+"\"", Logger.MINOR);
       params.put(name.toLowerCase(), value);
   }
 
   public String getParam(String name, String def)
   {
     String temp=getParam(name);
     if(temp==null) return def;
     else return temp;
   }
 
   // get number of command arguments
   public int getNumArgs()
   {
     return argVector.size();
   }
 
   // get command argument by position
   public String getArg(int position)
   {
     if (position >= 0 && position < argVector.size())
   {
       return (String) argVector.elementAt (position);
   }
     else
   {
       // no such argument
       return null;
   }
   }
 
   public String getParam(String name)
   {
     String r = (String)params.get(name.toLowerCase());
     if (r == null)
   {
       Logger.log("Params.java", 
            "No value specified for parameter '"+name+"'",
            Logger.DEBUGGING);
   }
     return r;
   }
 
   public long getlong(String name, long def)
   {
     String temp=getParam(name);
     if(temp==null) return def;
     else return getlong(name);
   }
 
   public long getlong(String name)
   {
     return (Long.parseLong(getParam(name)));
   }
 
   public int getint(String name, int def)
   {
     String temp=getParam(name);
     if(temp==null) return def;
     else return getint(name);
   }
 
   public int getint(String name)
   {
     return (Integer.parseInt(getParam(name)));
   }
 
   public short getshort(String name, short def)
   {
     String temp=getParam(name);
     if(temp==null) return def;
     else return getshort(name);
   }
 
   public short getshort(String name)
   {
     return (Short.parseShort(getParam(name)));
   }
 
   public void writeParams(String filename)
   {
     try
     {
     PrintWriter fw=new PrintWriter(new FileWriter(filename));
 
     Enumeration iterator=params.keys();
     while(iterator.hasMoreElements())
     {
       String name=(String)iterator.nextElement();
       fw.println(name.toLowerCase()+"="+params.get(name));
     }
     fw.close();
     }
     catch(IOException e)
     {
       Logger.log("Params.java","Could not write to config file",Logger.ERROR);
     }
   }
 
     private boolean isOption (String arg) {
   return (!noMoreOptions && arg.startsWith("-") && !arg.equals("-"));
     }
 
     /**
      * Hack to make an array on the fly
      **/
     static class ArrayFactory {
   public static String[] makeArray (String filename) {
       String[] arr = {filename};
       return arr;
   }
     }
 }