| ParameterList.java |
1 /*
2 * ParameterList.java
3 *
4 * Copyright (c) 1998-2005, The University of Sheffield.
5 *
6 * This file is part of GATE (see http://gate.ac.uk/), and is free
7 * software, licenced under the GNU Library General Public License,
8 * Version 2, June 1991 (in the distribution as file licence.html,
9 * and also available at http://gate.ac.uk/gate/licence.html).
10 *
11 * Hamish Cunningham, 15/Nov/2000
12 *
13 * $Id: ParameterList.java,v 1.7 2005/01/11 13:51:31 ian Exp $
14 */
15
16 package gate.creole;
17
18 import java.io.Serializable;
19 import java.util.*;
20
21 import gate.Factory;
22 import gate.FeatureMap;
23 import gate.util.Out;
24 import gate.util.Strings;
25
26 /** Models resource parameters lists as described in their
27 * <TT>creole.xml</TT> metadata. Parameters are stored as lists
28 * of disjunctions (<TT>OR'd</TT> sets in the metadata).
29 */
30 public class ParameterList implements Serializable
31 {
32 /** Debug flag */
33 private static final boolean DEBUG = false;
34
35 /** The runtime parameters */
36 protected List runtimeParameters = new ArrayList();
37
38 /** Get the list of runtime parameters
39 * (as a list of parameter disjunctions).
40 */
41 public List getRuntimeParameters() {
42 return runtimeParameters;
43 } // getRuntimeParameters()
44
45 /** The initialisation time parameters */
46 protected List initimeParameters = new ArrayList();
47
48 /** Get the list of initialisation-time parameters
49 * (as a list of parameter disjunctions).
50 */
51 public List getInitimeParameters() {
52 return initimeParameters;
53 } // getInitimeParameters()
54
55 /** Add a parameter disjunction.
56 * It is assumed that the parameters in a disjunction are all runtime
57 * or all init-time, never a mix of the two.
58 * @exception NoSuchElementException disjunction has no more elements.
59 */
60 public boolean add(List disjunction) {
61 boolean status = false;
62 Iterator iter = disjunction.iterator();
63 Parameter param = (Parameter) iter.next();
64
65 if(param.isRuntime()) {
66 status = runtimeParameters.add(disjunction);
67 } else {
68 status = initimeParameters.add(disjunction);
69 }
70
71 return status;
72 } // add(param)
73
74 /** Add all the members of a parameter list (as individual disjunctions) */
75 public boolean addAll(List c) {
76 boolean status = false;
77 Iterator iter = c.iterator();
78 while(iter.hasNext()) {
79 List disj = new ArrayList();
80 Parameter param = (Parameter) iter.next();
81 disj.add(param);
82 status = add(disj);
83 }
84
85 return status;
86 } // addAll(Collection)
87
88 /** Get default runtime parameter value set.
89 * Calls <TT>getDefaults(List)</TT>.
90 * @see #getDefaults(List)
91 */
92 public FeatureMap getRuntimeDefaults() throws ParameterException {
93 return getDefaults(runtimeParameters);
94 } // getRuntimeDefaults()
95
96 /** Get default initime parameter value set.
97 * Calls <TT>getDefaults(List)</TT>.
98 * @see #getDefaults(List)
99 */
100 public FeatureMap getInitimeDefaults() throws ParameterException {
101 return getDefaults(initimeParameters);
102 } // getInitimeDefaults()
103
104 /** Get default parameter value set. Where more than one default
105 * is possible amongst disjunctive parameters, only the first will be set.
106 * To check if the default set is comprehensive,
107 * use <TT>isFullyDefaulted()</TT>.
108 * @see #isFullyDefaulted()
109 */
110 public FeatureMap getDefaults(List parameters) throws ParameterException {
111 FeatureMap defaults = Factory.newFeatureMap();
112
113 // each element of the parameters list is a list of (disjunctive) params
114 Iterator disjIter = parameters.iterator();
115
116 // for each parameter disjunction in parameters
117 disjIterLoop:
118 while(disjIter.hasNext()) {
119 boolean optional = false; // were any of this disj optional?
120
121 // get an iterator for this disjunction of parameters
122 List paramDisj = (List) disjIter.next();
123 Iterator paramsIter = paramDisj.iterator();
124
125 // for each parameter in the disjunction
126 while(paramsIter.hasNext()) {
127 Parameter param = (Parameter) paramsIter.next();
128 if(DEBUG) Out.prln("Examining " + param);
129 if(!optional)
130 optional = param.isOptional();
131
132 // try and find a default value
133 Object defaultValue = param.calculateDefaultValue();
134
135 // no default found
136 if(defaultValue == null) {
137 // if none of this disj were optional, and we're the last, then
138 // we've got at least one non-optional param unset
139 if(!optional && !paramsIter.hasNext()) {
140 fullyDefaulted = false;
141 }
142
143 // valid default found - set it and continue with the next disj
144 } else {
145 defaults.put(param.getName(), defaultValue);
146 continue disjIterLoop;
147 }
148 } // paramsIter
149
150 } // disjIter
151
152 return defaults;
153 } // getDefaults()
154
155
156 // this stuff is for if we decide to do more thorough checking
157 // of parameterisation in Factory.createResource... but at present
158 // the gui checks pretty well so...
159 //
160 // /** Analyse a parameter-value feature map and return a list
161 // * of init time parameter disjunctions that are unset.
162 // */
163 // public List getUnsetInitimeParameters(FeatureMap paramValues) {
164 // List unsetDisj = new ArrayList();
165 //
166 // // for each init disj,
167 // // for each param,
168 // // if there's no value in paramValues
169 // // add this disj to rtnValue,
170 // // continue disjLoop
171 // } // getUnsetInitimeParameters(paramValues)
172 //
173 // /** Analyse a parameter-value feature map and return a list
174 // * of runtime parameter disjunctions that are unset.
175 // */
176 // public List getUnsetRuntimeParameters(FeatureMap paramValues) {
177 // } // getUnsetRuntimeParameters(paramValues)
178 //
179 // public List getUnsetInitimeParameters(
180 // FeatureMap paramValues, boolean includeOptional
181 // ) {
182 // } // getUnsetInitimeParameters(paramValues, includeOptional)
183 //
184 // public List getUnsetRuntimeParameters(
185 // FeatureMap paramValues, boolean includeOptional
186 // ) {
187 // } // getUnsetRuntimeParameters(paramValues, includeOptional)
188 //
189
190 /** Status of the last run of <TT>getDefaults(List)</TT>. */
191 protected boolean fullyDefaulted = false;
192
193 /** Get the status of the last run of <TT>getDefaults(List)</TT>.
194 * If the last run managed to find a default for all parameters
195 * that are part of a disjunction of which none are optional, then
196 * this status is true; else it is false.
197 * @see #getDefaults(List)
198 */
199 public boolean isFullyDefaulted() { return fullyDefaulted; }
200
201
202 /** String representation */
203 public String toString() {
204 StringBuffer s = new StringBuffer(Strings.getNl() + " ParameterList:");
205
206 Iterator iter = getRuntimeParameters().iterator();
207 if(iter.hasNext()) s.append(Strings.getNl() + " runtime params=");
208 while(iter.hasNext()) {
209 s.append(Strings.getNl() + " ");
210 List paramDisj = (List) iter.next();
211 Iterator iter2 = paramDisj.iterator();
212
213 while(iter2.hasNext())
214 s.append( (Parameter) iter2.next() + Strings.getNl() + " " );
215 }
216
217 iter = getInitimeParameters().iterator();
218 if(iter.hasNext()) s.append(Strings.getNl() + " initime params=");
219 while(iter.hasNext()) {
220 s.append(Strings.getNl() + " ");
221 List paramDisj = (List) iter.next();
222 Iterator iter2 = paramDisj.iterator();
223
224 while(iter2.hasNext())
225 s.append( (Parameter) iter2.next() + Strings.getNl() + " " );
226 }
227
228 return s.toString();
229 } // toString()
230
231 } // class ParameterList
232
233
234