home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.pdx.edu / 2014.02.ftp.ee.pdx.edu.tar / ftp.ee.pdx.edu / oss / cvs-2004 / OpenHamLog / Attic / OpenHamLog.java,v < prev    next >
Text File  |  2003-07-14  |  4KB  |  209 lines
  1. head    1.4;
  2. access;
  3. symbols;
  4. locks; strict;
  5. comment    @# @;
  6.  
  7.  
  8. 1.4
  9. date    2003.07.14.19.37.57;    author htodd;    state dead;
  10. branches;
  11. next    1.3;
  12.  
  13. 1.3
  14. date    2003.07.09.06.21.09;    author htodd;    state Exp;
  15. branches;
  16. next    1.2;
  17.  
  18. 1.2
  19. date    2003.07.07.00.57.47;    author htodd;    state Exp;
  20. branches;
  21. next    1.1;
  22.  
  23. 1.1
  24. date    2003.07.06.03.49.19;    author htodd;    state Exp;
  25. branches;
  26. next    ;
  27.  
  28.  
  29. desc
  30. @@
  31.  
  32.  
  33. 1.4
  34. log
  35. @Moving files and starting ant.
  36. @
  37. text
  38. @//: OpenHamLog.java
  39. // Counts words in a file, outputs
  40. // results in sorted form.
  41. import java.io.*;
  42. import java.util.*;
  43.  
  44. public class OpenHamLog {
  45.   private FileInputStream file;
  46.   private StreamTokenizer st;
  47.   private Hashtable counts = new Hashtable();
  48.   OpenHamLog(String filename)
  49.     throws FileNotFoundException {
  50.     try {
  51.  
  52.       file = new FileInputStream(filename);
  53.             Reader r = new BufferedReader(new InputStreamReader(file));
  54.  
  55.       st = new StreamTokenizer(r);
  56.       st.ordinaryChar('.');
  57.       st.ordinaryChar('-');
  58.             st.wordChars('_','_');
  59.     } catch(FileNotFoundException e) {
  60.       System.out.println(
  61.         "Could not open " + filename);
  62.       throw e;
  63.     }
  64.   }
  65.   void cleanup() {
  66.     try {
  67.       file.close();
  68.     } catch(IOException e) {
  69.       System.out.println(
  70.         "file.close() unsuccessful");
  71.     }
  72.   }
  73.   
  74.     void countWords() {
  75.     try {
  76.       while(st.nextToken() !=
  77.         StreamTokenizer.TT_EOF) {
  78.         String s;
  79.         switch(st.ttype) {
  80.           case StreamTokenizer.TT_EOL:
  81.             s = new String("EOL");
  82.             break;
  83.           case StreamTokenizer.TT_NUMBER:
  84.             s = Double.toString(st.nval);
  85.             break;
  86.           case StreamTokenizer.TT_WORD:
  87.             s = st.sval; // Already a String
  88.             break;
  89.           default: // single character in ttype
  90.             s = String.valueOf((char)st.ttype);
  91.         }
  92.         if(counts.containsKey(s))
  93.           ((Counter)counts.get(s)).increment();
  94.         else
  95.           counts.put(s, new Counter());
  96.       }
  97.     } catch(IOException e) {
  98.       System.out.println(
  99.         "st.nextToken() unsuccessful");
  100.     }
  101.   }
  102.  
  103.   void printWords() {
  104.     try {
  105.       while(st.nextToken() !=
  106.         StreamTokenizer.TT_EOF) {
  107.         String s;
  108.         switch(st.ttype) {
  109.           case StreamTokenizer.TT_EOL:
  110.             s = new String("EOL");
  111.             break;
  112.           case StreamTokenizer.TT_NUMBER:
  113.             s = Double.toString(st.nval);
  114.             break;
  115.           case StreamTokenizer.TT_WORD:
  116.             s = st.sval; // Already a String
  117.             break;
  118.           default: // single character in ttype
  119.             s = String.valueOf((char)st.ttype);
  120.         }
  121.                 System.out.println(s);
  122.       }
  123.     } catch(IOException e) {
  124.       System.out.println(
  125.         "st.nextToken() unsuccessful");
  126.     }
  127.   }
  128.     
  129.   Enumeration values() {
  130.     return counts.elements();
  131.   }
  132.   Enumeration keys() { return counts.keys(); }
  133.   Counter getCounter(String s) {
  134.     return (Counter)counts.get(s);
  135.   }
  136.   Enumeration sortedKeys() {
  137.     Enumeration e = counts.keys();
  138.     StrSortVector sv = new StrSortVector();
  139.     while(e.hasMoreElements())
  140.       sv.addElement((String)e.nextElement());
  141.     // This call forces a sort:
  142.     return sv.elements();
  143.  
  144.   }
  145.   public static void main(String[] args) {
  146.     try {
  147.       OpenHamLog wc = new OpenHamLog(args[0]);
  148.             wc.printWords();
  149. //      wc.countWords();
  150. //      Enumeration keys = wc.sortedKeys();
  151. //      while(keys.hasMoreElements()) {
  152. //        String key = (String)keys.nextElement();
  153. //        System.out.println(key + ": "
  154. //                 + wc.getCounter(key).read());
  155. //      }
  156.       wc.cleanup();
  157.     } catch(Exception e) {
  158.       e.printStackTrace();
  159.     }
  160.   }
  161. } ///:~ 
  162. @
  163.  
  164.  
  165. 1.3
  166. log
  167. @*** empty log message ***
  168. @
  169. text
  170. @@
  171.  
  172.  
  173. 1.2
  174. log
  175. @Sunday night
  176. @
  177. text
  178. @a6 6
  179. class Counter {
  180.     private int i = 1;
  181.     int read() { return i; }
  182.     void increment() { i++; }
  183. }
  184.  
  185. @
  186.  
  187.  
  188. 1.1
  189. log
  190. @Just adding a garbage file to start cvs.
  191. @
  192. text
  193. @d27 1
  194. d42 2
  195. a43 1
  196.   void countWords() {
  197. d71 27
  198. d117 8
  199. a124 7
  200.       wc.countWords();
  201.       Enumeration keys = wc.sortedKeys();
  202.       while(keys.hasMoreElements()) {
  203.         String key = (String)keys.nextElement();
  204.         System.out.println(key + ": "
  205.                  + wc.getCounter(key).read());
  206.       }
  207. @
  208.  
  209.