001 package edu.upenn.cis.propbank_shen;
002 import java.util.*;
003
004 /**
005 This class represents an "argument" in a "predicate argument
006 structure". As such, on a logical/mathematical level, one
007 may construe an "argument" as a projection of tuple, where
008 the tuple is an element of a relation "defined" by the verb
009 in question. For example, the sentence
010 <p><center>
011 John gave Sue a Penny.
012 </center><p>
013
014 may be viewed as denoting, amongst other
015 things, a predicate "gave" with three "arguments", as in
016 gave(John,Sue,Penny).
017 <p>
018 In the propbank, each of these arguments is constituted by
019 up to three things (two of which arg optional):
020
021 <ol>
022 <li> an argument label, as defined by the class ArgLabel
023 <li> an optional modifying label, as defined by the class ModLabel
024 <li>an optional argument location, as defined by the class ArgLoc
025 </ol>
026
027 @author Scott Cotton
028 @see edu.upenn.cis.propbank_shen.ArgLabel
029 @see edu.upenn.cis.propbank_shen.ModLabel
030 @see edu.upenn.cis.propbank_shen.ArgLoc
031
032 */
033 public class Argument implements Comparable{
034
035 /** the primary argument label associated with this Argument */
036 public ArgLabel arg_label;
037 /** the secondary label associated with this argument, or null */
038 public ModLabel mod_label; // can be null
039 /** the edu.upenn.cis.treebank location associated with this argument, or null */
040 public ArgLoc location; // can be null
041
042 /** the separator for the parts for one-line at a time representation */
043 public static final String sep="-";
044
045 /** create an Argument from just a label */
046 public Argument(ArgLabel albl) {
047 arg_label = albl;
048 location = null;
049 mod_label = null;
050 }
051
052 /** create an Argument from an argument label and a modifiying label */
053 public Argument(ArgLabel albl, ModLabel mlbl) {
054 arg_label = albl;
055 mod_label = mlbl;
056 location = null;
057 }
058
059 /** create an Argument from an argument label and a location */
060 public Argument(ArgLabel albl, ArgLoc aloc) {
061 arg_label = albl;
062 mod_label = null;
063 location = aloc;
064 }
065
066 /** create an Argument from an argument label, a modifying label, and a location */
067 public Argument(ArgLabel albl, ModLabel mlbl, ArgLoc aloc) {
068 arg_label = albl;
069 mod_label = mlbl;
070 location = aloc;
071 }
072
073 public int compareTo(Object o) {
074 Argument arg = (Argument) o;
075 int locComparison = this.location.compareTo(arg.location);
076 if (locComparison != 0) return locComparison;
077 String labelString = arg_label.toString();
078 if (mod_label != null) labelString += mod_label.toString();
079 String labelString2 = arg.arg_label.toString();
080 if (arg.mod_label != null) labelString2 += arg.mod_label.toString();
081 return labelString.compareTo(labelString2);
082 }
083
084 /** set the argument's location to loc
085 @param loc the new argument location
086 */
087 public void setLocation(ArgLoc loc) { location = loc;}
088
089
090 public ArgLoc getLocation() { return this.location; }
091
092 /**
093 set the arguments modifying label.
094 @param ml the new modifying label
095 */
096 public void setMod(ModLabel ml) { mod_label = ml; }
097
098 /**
099 set the argument's primary label.
100 @param al the new primary label
101 */
102 public void setLabel(ArgLabel al) { arg_label = al; }
103
104 /** produce a canonical string from the Argument */
105 public String toString() {
106 String locstr;
107 if (location == null) { locstr = "?:?"; }
108 else { locstr = location.toString(); }
109
110 String modstr;
111 if (mod_label == null) { modstr = "";}
112 else { modstr = sep + mod_label.toString(); }
113
114 String astr = arg_label.toString();
115
116 return locstr + sep + astr + modstr;
117 }
118
119 public boolean equals (Object o) {
120 if (!(o instanceof Argument))
121 return false;
122 Argument a = (Argument)o;
123 return
124 ((a.arg_label == arg_label) ||
125 (a.arg_label != null && a.arg_label.equals(arg_label))) &&
126 ((a.mod_label == mod_label) ||
127 (a.mod_label != null && a.mod_label.equals(mod_label))) &&
128 ((a.location == location) ||
129 (a.location != null && a.location.equals(location)));
130 }
131
132 // public int hashCode () {
133 // return arg_label.hashCode() + 19 * mod_label.hashCode() +
134 // 23 * location.hashCode();
135 // }
136
137 /**
138 convert a string into an "argument".
139
140 @param s the string to be converted.
141 */
142 public static Argument ofString(String s) throws CorruptDataException {
143 StringTokenizer tok = new StringTokenizer(s, sep);
144 int nelts = tok.countTokens();
145 if (nelts < 2 || nelts > 3) {
146 throw new CorruptDataException("invalid argument string, too few or too many parts: " + s);
147 }
148 String loctok = tok.nextToken();
149 ArgLoc aloc = null;
150 if (loctok == "?:?") {
151 aloc = null;
152 } else {
153 aloc = ArgLoc.ofString(loctok);
154 }
155 ArgLabel albl = ArgLabel.ofString(tok.nextToken());
156 if (nelts == 3) {
157 ModLabel mlbl = ModLabel.ofString(tok.nextToken());
158 return new Argument(albl, mlbl, aloc);
159 } else {
160 return new Argument(albl, aloc);
161 }
162 }
163 }
164