src2/fr/orsay/lri/varna/applications/BasicINI.java

   1 package fr.orsay.lri.varna.applications;
   2
   3 import java.io.File;
   4 import java.io.FileReader;
   5 import java.io.FileWriter;
   6 import java.io.Reader;
   7 import java.io.StreamTokenizer;
   8 import java.util.ArrayList;
   9 import java.util.Arrays;
  10 import java.util.Hashtable;
  11 import java.util.Set;
  12
  13 public class BasicINI {
  14
  15         private Hashtable<String,Hashtable<String,String>> _data = new Hashtable<String,Hashtable<String,String>>();
  16
  17
  18         public void addItem(String category, String key, String val)
  19         {
  20                 if (!_data.containsKey(category))
  21                 {
  22                         _data.put(category, new Hashtable<String,String>());
  23                 }
  24                 System.out.println("[E]"+key+"->"+val);
  25                 _data.get(category).put(key,val);
  26         }
  27
  28
  29         public String getItem(String category, String key)
  30         {
  31                 String result = "";
  32                 if (_data.containsKey(category))
  33                 {
  34                         if (_data.get(category).containsKey(key))
  35                         {
  36                                 result = _data.get(category).get(key);
  37                         }
  38                 }
  39                 return result;
  40         }
  41
  42         public ArrayList<String> getItemList(String category)
  43         {
  44                 ArrayList<String> result = new ArrayList<String>();
  45                 if (_data.containsKey(category))
  46                 {
  47                         for (String key: _data.get(category).keySet())
  48                         {
  49                                 result.add(_data.get(category).get(key));
  50                         }
  51                 }
  52                 return result;
  53         }
  54
  55         public BasicINI(){
  56
  57         }
  58
  59         public static void saveINI(BasicINI data, String filename)
  60         {
  61                 try
  62                 {
  63                         FileWriter out = new FileWriter(filename);
  64                         Set<String> cats = data._data.keySet();
  65                         String[] sortedCats = new String[cats.size()];
  66                         sortedCats = cats.toArray(sortedCats);
  67                         Arrays.sort(sortedCats);
  68                         for (int i=0;i<sortedCats.length;i++)
  69                         {
  70                                 String cat = sortedCats[i];
  71                                 out.write("["+cat+"]\n");
  72                                 Hashtable<String,String> vals = data._data.get(cat);
  73                                 Set<String> keys = vals.keySet();
  74                                 String[] sortedKeys = new String[keys.size()];
  75                                 sortedKeys = keys.toArray(sortedKeys);
  76                                 for(int j=0;j<sortedKeys.length;j++)
  77                                 {
  78                                         String key = sortedKeys[j];
  79                                         String val = vals.get(key);
  80                                         out.write(key+"="+val+"\n");
  81                                 }
  82                         }
  83                         out.close();
  84                 }
  85                 catch(Exception e3)
  86                 {e3.printStackTrace();}
  87         }
  88
  89         public static BasicINI loadINI(String filename)
  90         {
  91                 BasicINI result = new BasicINI();
  92
  93                 // Etats du parsing simplifie ...
  94                 final int CATEGORY = 0;
  95                 final int KEY = 1;
  96                 final int VAL = 2;
  97                 int state = KEY;
  98                 String category = "";
  99                 String key = "";
 100                 String val = "";
 101
 102                 try
 103                 {
 104                         System.out.println("Loading "+new File(filename).getAbsolutePath());
 105
 106                         Reader r = new FileReader(filename);
 107                         StreamTokenizer s = new StreamTokenizer(r);
 108                         s.resetSyntax();
 109                         s.eolIsSignificant(true);
 110                         s.wordChars('\u0000','\u00FF');
 111                         s.whitespaceChars('\u0000','\u000F');
 112                         s.ordinaryChar('[');
 113                         s.ordinaryChar(']');
 114                         s.ordinaryChar('=');
 115                         int token = s.nextToken();
 116                         while(token != StreamTokenizer.TT_EOF)
 117                         {
 118                                 switch(token)
 119                                 {
 120                                 case('[') :
 121                                 {
 122                                         state = CATEGORY;
 123                                 }
 124                                 break;
 125                                 case(']') :
 126                                 {
 127                                         state = KEY;
 128                                 }
 129                                 break;
 130                                 case('=') :
 131                                 {
 132                                         state = VAL;
 133                                 }
 134                                 break;
 135                                 case(StreamTokenizer.TT_EOL) :
 136                                 {
 137                                         if (state==VAL)
 138                                         {
 139                                           state = KEY;
 140                                           result.addItem(category, key, val);
 141                                           key="";
 142                                           val="";
 143                                         }
 144                                 }
 145                                 case(StreamTokenizer.TT_WORD) :
 146                                 {
 147                                         String word = s.sval;
 148                                         switch(state)
 149                                         {
 150                                         case(CATEGORY) :
 151                                         {
 152                                                 category = word;
 153                                         }
 154                                         break;
 155                                         case(KEY) :
 156                                         {
 157                                                 key = word;
 158                                         }
 159                                         break;
 160                                         case(VAL) :
 161                                         {
 162                                                 val = word;
 163                                         }
 164                                         break;
 165                                         }
 166                                 }
 167                                 break;
 168                                 }
 169                                 token = s.nextToken();
 170                         }
 171                 }
 172                 catch(Exception exc1)
 173                 {exc1.printStackTrace();}
 174                 return result;
 175         }
 176
 177
 178 }