001 /** 002 * LTAG-spinal API, an interface to the treebank format introduced by Libin Shen. 003 * Copyright (C) 2007 Lucas Champollion 004 * 005 * This program is free software: you can redistribute it and/or modify 006 * it under the terms of the GNU General Public License as published by 007 * the Free Software Foundation, either version 3 of the License, or 008 * (at your option) any later version. 009 * 010 * This program is distributed in the hope that it will be useful, 011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 013 * GNU General Public License for more details. 014 * 015 * You should have received a copy of the GNU General Public License 016 * along with this program. If not, see <http://www.gnu.org/licenses/>. 017 * 018 */ 019 package edu.upenn.cis.spinal; 020 021 import java.io.*; 022 import java.util.*; 023 024 /** 025 * Inherit from this abstract class to create standalone command-line applications 026 * that operate on a file containing an LTAG-spinal annotated sentence or sentences. 027 * See the other <code>XYZWalker</code> classes in this packages for examples. 028 * All inherited classes should include the following method: 029 * <pre> 030 * public static void main(String argv[]) { 031 * new XYZWalker().process(argv); 032 * } 033 * </pre> 034 * 035 * @author Lucas Champollion 036 * 037 */ 038 public abstract class AbstractWalker { 039 040 /** 041 * Contains the arguments that have been passed to {@link #process(String[])}. 042 */ 043 protected String[] args; 044 045 /** 046 * Indicates whether {@link #terminate()} has been called. 047 */ 048 protected boolean terminate=false; 049 050 /** 051 * Returns the string array of arguments that has been passed to 052 * {@link #process(String[])}. 053 * 054 * @return the arguments 055 */ 056 protected String[] getArgs() { 057 return this.args; 058 } 059 060 061 /** 062 * Call this method from within {@link #forEachSentence(Sentence)} to 063 * instruct {@link #process(String[])} to skip any remaining sentences. 064 * {@link #process(String[])} will 065 * still call {@link #wrapUp()} even after 066 * this method is invoked. 067 * 068 * 069 */ 070 protected void terminate() { 071 this.terminate=true; 072 } 073 074 /** 075 * This method calls {@link #init()}, then opens a file in LTAG-spinal format 076 * using the first element 077 * of the <code>args</code> array as the filename, and reads in elementary trees from that file. 078 * On each of these trees, it calls {@link #forEachSentence(Sentence)}. 079 * When {@link #terminate()} is called or the end of the file is reached, 080 * the method calls {@link #wrapUp()}. 081 * 082 * @param args an array of arguments. The first of them is used as a filename 083 * to indicate the location of the file containing LTAG-spinal annotation. 084 * 085 */ 086 protected void process(String[] args) { 087 088 this.args = args; 089 090 if (args.length == 0) { 091 printUsage(); 092 return; 093 } 094 095 init(); 096 097 098 String filename=args[0]; 099 BufferedReader input=null; 100 101 try { 102 input=new BufferedReader(new FileReader(filename)); 103 } catch (IOException e) { 104 System.err.println(e); 105 e.printStackTrace(); 106 System.exit(1); 107 } 108 109 110 Sentence t=null; 111 112 113 try { 114 while ((t=Sentence.readTree(input))!=null) { 115 116 forEachSentence(t); 117 if (terminate) return; 118 } 119 } catch (Exception e) { 120 System.err.println(e); 121 e.printStackTrace(); 122 System.exit(1); 123 } 124 125 wrapUp(); 126 } 127 128 129 /** 130 * Implementations of this method should specify what (if anything) 131 * the class should do before attempting to read in a file. 132 * 133 */ 134 protected abstract void init(); 135 136 /** 137 * Implementations of this method should specify what the class 138 * should do on reading in a sentence (a derivation tree) from the file. 139 * 140 * @param t the current <code>Sentence</code> object 141 */ 142 public abstract void forEachSentence(Sentence t); 143 144 /** 145 * Implementations of this method should specify what (if anything) 146 * the class should do upon reading all sentences from the file. The 147 * {@link #process(String[])} method also calls this if {@link #terminate()} 148 * has been invoked. 149 * 150 */ 151 protected abstract void wrapUp(); 152 153 /** 154 * Implementations of this method should print out a short string 155 * to <code>stdout</code> 156 * describing the function of the class. This method is automatically 157 * called by {@link #process(String[])} when no command-line 158 * argument is passed. 159 * 160 */ 161 protected abstract void printUsage(); 162 163 164 }