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 / AdifFileImport.java,v next >
Text File  |  2003-07-14  |  9KB  |  387 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.56;    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.21.13.09;    author htodd;    state Exp;
  20. branches;
  21. next    1.1;
  22.  
  23. 1.1
  24. date    2003.07.07.00.52.04;    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. @/* file name  : AdifFileImport.java
  39.  * authors    : Hisashi T Fujinaka
  40.  * created    : Sun Jul  6 17:08:33 2003
  41.  *
  42.  * Copyright (c) 2003 Hisashi T Fujinaka
  43.  *
  44.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  45.  * of this software and associated documentation files (the "Software"), to
  46.  * deal in the Software without restriction, including without limitation the
  47.  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  48.  * sell copies of the Software, and to permit persons to whom the Software is
  49.  * furnished to do so, subject to the following conditions:
  50.  *
  51.  * The above copyright notice and this permission notice shall be included in
  52.  * all copies or substantial portions of the Software.
  53.  *
  54.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  55.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  56.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  57.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  58.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  59.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  60.  * IN THE SOFTWARE.
  61.  *
  62.  */
  63.  
  64. import java.io.*;
  65. import java.util.*;
  66.  
  67. /** 
  68.  * 
  69.  * 
  70.  * @@author Hisashi T Fujinaka
  71.  * @@version 0.1
  72.  */
  73. class Counter {
  74.   private int i = 1;
  75.  
  76.   int read() {
  77.     return i;
  78.   }
  79.  
  80.   void increment() {
  81.     i++;
  82.   }
  83. }
  84.  
  85. /** 
  86.  * AdifFileImport
  87.  * 
  88.  * @@author Hisashi T Fujinaka
  89.  * @@version 0.1
  90.  */
  91. public class AdifFileImport {
  92.   private FileInputStream file;
  93.   private StreamTokenizer st;
  94.   private Hashtable fieldCount = new Hashtable();
  95.  
  96.   /** 
  97.    * AdifFileImport
  98.    * 
  99.    * @@param filename 
  100.    * @@throws FileNotFoundException 
  101.    */
  102.   AdifFileImport(String filename) throws FileNotFoundException {
  103.     try {
  104.       file = new FileInputStream(filename);
  105.       Reader r = new BufferedReader(new InputStreamReader(file));
  106.  
  107.       st = new StreamTokenizer(r);
  108.       st.slashSlashComments(false);
  109.       st.slashStarComments(false);
  110.       st.lowerCaseMode(false);
  111.       st.ordinaryChar('.');
  112.       st.ordinaryChar('-');
  113.       st.ordinaryChar('\'');
  114.       st.wordChars('_','_');
  115.     } catch(FileNotFoundException e) {
  116.       System.out.println("Could not open " + filename);
  117.       throw e;
  118.     }
  119.   }
  120.  
  121.   /** 
  122.    * This method uses the StreamTokenizer and a hash table to count the number
  123.    * of occurences of the fields.
  124.    */
  125.   void countFields() {
  126.     String s;
  127.     try {
  128.       // eat the header
  129.       if((st.nextToken() != StreamTokenizer.TT_EOF) && 
  130.           (st.ttype != '<')) {
  131.         while((st.nextToken() != StreamTokenizer.TT_EOF) && 
  132.             (st.ttype != '<')) {
  133.         }
  134.       } else {
  135.         System.out.println("No header");
  136.         switch(st.ttype) {
  137.           case StreamTokenizer.TT_EOL:
  138.             s = new String("EOL");
  139.             break;
  140.           case StreamTokenizer.TT_NUMBER:
  141.             s = Double.toString(st.nval);
  142.             break;
  143.           case StreamTokenizer.TT_WORD:
  144.             s = st.sval;
  145.             break;
  146.           default: // just a char
  147.             s = String.valueOf((char)st.ttype);
  148.         }
  149.         System.out.println(s);
  150.       }
  151.  
  152.       if ((st.nextToken() != StreamTokenizer.TT_WORD) && 
  153.           (st.sval != "EOH")) {
  154.         System.out.println("Header error");
  155.       } else {
  156.         switch(st.ttype) {
  157.           case StreamTokenizer.TT_EOL:
  158.             s = new String("EOL");
  159.             break;
  160.           case StreamTokenizer.TT_NUMBER:
  161.             s = Double.toString(st.nval);
  162.             break;
  163.           case StreamTokenizer.TT_WORD:
  164.             s = st.sval;
  165.             break;
  166.           default: // just a char
  167.             s = String.valueOf((char)st.ttype);
  168.         }
  169.         System.out.println(s);
  170.       }
  171.  
  172.  
  173.       // start getting headers
  174.       do {
  175.         if(st.ttype != '<') {
  176.           // wait for <, which starts the data field
  177.           while((st.nextToken() != StreamTokenizer.TT_EOF) &&
  178.               (st.ttype != '<')) {
  179.             // we got an EOR without the <
  180.             if ((st.ttype == StreamTokenizer.TT_WORD) &&
  181.                 (st.sval == "EOR")) {
  182.             }
  183.  
  184.             //debug
  185.             switch(st.ttype) {
  186.               case StreamTokenizer.TT_EOL:
  187.                 s = new String("EOL");
  188.                 break;
  189.               case StreamTokenizer.TT_NUMBER:
  190.                 s = Double.toString(st.nval);
  191.                 break;
  192.               case StreamTokenizer.TT_WORD:
  193.                 s = st.sval;
  194.                 break;
  195.               default: // just a char
  196.                 s = String.valueOf((char)st.ttype);
  197.             }
  198.             System.out.println(s);
  199.             //debug
  200.             
  201.           }
  202.  
  203.           if(st.nextToken() != StreamTokenizer.TT_EOF){
  204.             if(st.ttype == StreamTokenizer.TT_WORD) {
  205.               s = st.sval;
  206.  
  207.               //debug
  208.               System.out.println(s);
  209.  
  210.               if(fieldCount.containsKey(s)) {
  211.                 ((Counter)fieldCount.get(s)).increment();
  212.               } else {
  213.                 fieldCount.put(s, new Counter());
  214.               }
  215.             } else {
  216.               // print out error cases
  217.               System.out.println("AARRGH");
  218.               switch(st.ttype) {
  219.                 case StreamTokenizer.TT_EOL:
  220.                   s = new String("EOL");
  221.                   break;
  222.                 case StreamTokenizer.TT_NUMBER:
  223.                   s = Double.toString(st.nval);
  224.                   break;
  225.                 case StreamTokenizer.TT_WORD:
  226.                   s = st.sval;
  227.                   break;
  228.                 default: // just a char
  229.                   s = String.valueOf((char)st.ttype);
  230.               }
  231.               System.out.print("ADIF error, line: " + st.lineno() + " ");
  232.               System.out.println(s);
  233.             }
  234.           }
  235.         }
  236.       } while(st.nextToken() != StreamTokenizer.TT_EOF);
  237.     } catch(IOException e) {
  238.       System.out.println("st.nextToken() unsuccessful");
  239.     }
  240.     Enumeration keys = sortedKeys();
  241.     int numkeys = 0;
  242.     while(keys.hasMoreElements()) {
  243.       ++numkeys;
  244.       String key = (String)keys.nextElement();
  245.       System.out.println(key + ": " + getCounter(key).read());
  246.     }
  247.     System.out.println("keys: " + numkeys);
  248.   }
  249.  
  250.   /** 
  251.    * This method merely closes the file.
  252.    */
  253.   void cleanup() {
  254.     try {
  255.       file.close();
  256.     } catch(IOException e) {
  257.       System.out.println(
  258.         "file.close() unsuccessful");
  259.     }
  260.   }
  261.  
  262.   Counter getCounter(String s) {
  263.     return (Counter)fieldCount.get(s);
  264.   }
  265.  
  266.   Enumeration sortedKeys() {
  267.     Enumeration e = fieldCount.keys();
  268.     StrSortVector sv = new StrSortVector();
  269.     while(e.hasMoreElements())
  270.       sv.addElement((String)e.nextElement());
  271.     // This call forces a sort:
  272.     return sv.elements();
  273.   }
  274.  
  275.   /** 
  276.    * main
  277.    * 
  278.    * @@param args 
  279.    */
  280.   public static void main(String[] args) {
  281.     try {
  282.       AdifFileImport afi = new AdifFileImport(args[0]);
  283.       afi.countFields();
  284.       afi.cleanup();
  285.  
  286.     } catch(Exception e) {
  287.       e.printStackTrace();
  288.     }
  289.   }
  290. }
  291. @
  292.  
  293.  
  294. 1.3
  295. log
  296. @*** empty log message ***
  297. @
  298. text
  299. @@
  300.  
  301.  
  302. 1.2
  303. log
  304. @Monday morning
  305. @
  306. text
  307. @d40 2
  308. a41 2
  309.         return i;
  310.     }
  311. d44 2
  312. a45 2
  313.         i++;
  314.     }
  315. d71 3
  316. d76 1
  317. d85 2
  318. a86 1
  319.    * count the fields in the adif file
  320. d89 1
  321. a89 1
  322.         int lineCount = 0;
  323. d91 75
  324. a165 6
  325.       while(st.nextToken() != StreamTokenizer.TT_EOF) {
  326.                 if (StreamTokenizer.TT_EOL) {
  327.                     ++lineCount;
  328.                 }
  329.         String s;
  330.         if((st.ttype != StreamTokenizer.TT_WORD) && (st.ttype == '<')) {
  331. a166 3
  332.                         if (st.ttype == StreamTokenizer.TT_EOL) {
  333.                             ++lineCount;
  334.                         }
  335. d169 4
  336. d179 2
  337. a180 2
  338.                             // print out error cases
  339.               System.out.print("ADIF error, line: " + lineCount + " ");
  340. d194 1
  341. d199 1
  342. a199 1
  343.       }
  344. d203 8
  345. d213 3
  346. a246 6
  347.       Enumeration keys = afi.sortedKeys();
  348.       while(keys.hasMoreElements()) {
  349.         String key = (String)keys.nextElement();
  350.         System.out.println(key + ": " + afi.getCounter(key).read());
  351.       }
  352.  
  353. d253 1
  354. a253 1
  355. } ///:~ 
  356. @
  357.  
  358.  
  359. 1.1
  360. log
  361. @new
  362. @
  363. text
  364. @d38 8
  365. a45 2
  366.   int read() { return i; }
  367.   void increment() { i++; }
  368. d84 1
  369. d87 3
  370. d93 3
  371. d104 2
  372. a105 1
  373.               System.out.print("odd: ");
  374. d114 1
  375. a114 1
  376.                   s = st.sval; // Already a String
  377. d116 1
  378. a116 1
  379.                 default: // single character in ttype
  380. a135 4
  381.   }
  382.  
  383.   Enumeration keys() {
  384.     return fieldCount.keys();
  385. @
  386.  
  387.