1 package org.apache.torque.generator.control; 2 3 /* 4 * Licensed to the Apache Software Foundation (ASF) under one 5 * or more contributor license agreements. See the NOTICE file 6 * distributed with this work for additional information 7 * regarding copyright ownership. The ASF licenses this file 8 * to you under the Apache License, Version 2.0 (the 9 * "License"); you may not use this file except in compliance 10 * with the License. You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, 15 * software distributed under the License is distributed on an 16 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 17 * KIND, either express or implied. See the License for the 18 * specific language governing permissions and limitations 19 * under the License. 20 */ 21 22 import java.io.File; 23 import java.util.ArrayList; 24 import java.util.List; 25 26 import org.apache.torque.generator.configuration.UnitConfiguration; 27 import org.apache.torque.generator.configuration.controller.OutletReference; 28 import org.apache.torque.generator.configuration.controller.Output; 29 import org.apache.torque.generator.option.Option; 30 import org.apache.torque.generator.option.OptionName; 31 import org.apache.torque.generator.option.Options; 32 import org.apache.torque.generator.outlet.Outlet; 33 import org.apache.torque.generator.qname.Namespace; 34 import org.apache.torque.generator.qname.QualifiedName; 35 import org.apache.torque.generator.source.SourceElement; 36 import org.apache.torque.generator.source.SourceProvider; 37 import org.apache.torque.generator.variable.VariableStore; 38 39 /** 40 * The state of the controller. Contains all stuff the controller needs to 41 * track. 42 */ 43 public class ControllerState 44 { 45 /** 46 * The Source provider which is currently used. 47 */ 48 private SourceProvider sourceProvider; 49 50 /** 51 * The output which currently processed . 52 */ 53 private Output output; 54 55 /** 56 * The current stack of outlets being executed. 57 */ 58 private List<Outlet> outlets = new ArrayList<Outlet>(); 59 60 /** 61 * The root element of the source graph. 62 */ 63 private SourceElement rootElement; 64 65 /** 66 * The current element within the source. 67 */ 68 private SourceElement sourceElement; 69 70 /** 71 * The generation unit which is currently processed. 72 */ 73 private UnitConfiguration unitConfiguration; 74 75 /** 76 * The reference in the controller to the root outlet. 77 * May override mergepoints in the outlets. 78 */ 79 private OutletReference rootOutletReference; 80 81 /** 82 * The variable store. 83 */ 84 private VariableStore variableStore = new VariableStore(); 85 86 /** 87 * The currently generated output file. May be null if 88 * no file is currently generated (e.g. if the filename is currently 89 * generated). 90 */ 91 private File outputFile; 92 93 /** 94 * The name of the currently processed source file. May be null if 95 * no source file is used (e.g. if the input is created by other means 96 * than reading a file). 97 */ 98 private File sourceFile; 99 100 /** 101 * The name space in which the current outlet operates. 102 */ 103 private Namespace outletNamespace; 104 105 /** 106 * Returns the source provider which is currently in use. 107 * 108 * @return the current source provider. 109 */ 110 public SourceProvider getSourceProvider() 111 { 112 return sourceProvider; 113 } 114 115 /** 116 * Sets the source provider which is currently in use. 117 * 118 * @param sourceProvider the current source provider. 119 */ 120 public void setSourceProvider(SourceProvider sourceProvider) 121 { 122 this.sourceProvider = sourceProvider; 123 } 124 125 /** 126 * Returns the output declaration which is currently processed. 127 * 128 * @return the output declaration which is currently processed, may be null 129 * only if no output is processed at the moment. 130 */ 131 public Output getOutput() 132 { 133 return output; 134 } 135 136 /** 137 * Sets the output declaration which is currently processed. 138 * 139 * @param output the output which is currently processed. 140 */ 141 void setOutput(Output output) 142 { 143 this.output = output; 144 } 145 146 /** 147 * Returns the topmost outlet in the stack of outlets. 148 * 149 * @return the topmost outlet in the stack of outlets, or null 150 * if the stack is empty. 151 */ 152 public Outlet getOutlet() 153 { 154 if (outlets.isEmpty()) 155 { 156 return null; 157 } 158 return outlets.get(outlets.size() - 1); 159 } 160 161 /** 162 * Pushes a outlet onto the stack of outlets. 163 * 164 * @param outlet the outlet to be added to the stack of outlets, 165 * not null. 166 */ 167 public void pushOutlet(Outlet outlet) 168 { 169 if (outlet == null) 170 { 171 throw new NullPointerException("outlet must not be null"); 172 } 173 this.outlets.add(outlet); 174 } 175 176 /** 177 * Pops the topmost outlets from the stack of outlets. 178 * 179 * @return the removed outlet, not null. 180 * 181 * @throws IndexOutOfBoundsException if the stack is empty. 182 */ 183 public Outlet popOutlet() 184 { 185 return outlets.remove(outlets.size() - 1); 186 } 187 188 /** 189 * Returns the current source element. Does not return null 190 * during generation. 191 * 192 * @return the current source element. 193 */ 194 public SourceElement getSourceElement() 195 { 196 return sourceElement; 197 } 198 199 /** 200 * Sets the current source element. 201 * 202 * @param sourceElement the new current source element, or null 203 * to remove the current source element. 204 */ 205 public void setSourceElement(SourceElement sourceElement) 206 { 207 this.sourceElement = sourceElement; 208 } 209 210 /** 211 * Returns the root element of the current source. 212 * 213 * @return The the root element of the current source; 214 * may be null only if no source is currently processed. 215 */ 216 public SourceElement getRootElement() 217 { 218 return rootElement; 219 } 220 221 /** 222 * Sets the root element of the current source. 223 * 224 * @param rootElement the the root element of the current source, 225 * or null to remove the current root element. 226 */ 227 public void setRootElement(SourceElement rootElement) 228 { 229 this.rootElement = rootElement; 230 } 231 232 /** 233 * Returns the reference to the current outlet. 234 * 235 * @return the reference to the current outlet, or null if no 236 * outlet is currently active. 237 */ 238 public OutletReference getRootOutletReference() 239 { 240 return rootOutletReference; 241 } 242 243 /** 244 * Sets the reference to the root outlet. 245 * 246 * @param rootOutletReference the reference to the root outlet 247 * (i.e. the outlet which produces the whole content), 248 * or null to remove the reference. 249 */ 250 void setRootOutletReference(OutletReference rootOutletReference) 251 { 252 this.rootOutletReference = rootOutletReference; 253 } 254 255 256 /** 257 * Sets the name space of the outlet which is currently active. 258 * 259 * @param namespace the namespace of the outlet which is currently 260 * active, or null to remove the name space. 261 */ 262 void setOutletNamespace(Namespace namespace) 263 { 264 outletNamespace = namespace; 265 } 266 267 /** 268 * Returns the namespace of the outlet which is currently active. 269 * 270 * @return the name space of the active outlet. May be null only 271 * if no generation is in progress. 272 */ 273 public Namespace getOutletNamespace() 274 { 275 return outletNamespace; 276 } 277 278 /** 279 * Calculates the value of an option in the current outlet's context. 280 * The default namespace which is used when no namespace is given in 281 * <code>name</code> is the namespace of the currently used outlet. 282 * 283 * @param name the name of the option, can contain a namespace. 284 * 285 * @return The value of the option, or null if no option with that name 286 * is visible from the given namespace. 287 */ 288 public Object getOption(String name) 289 { 290 Options options = unitConfiguration.getOptions(); 291 QualifiedName qualifiedName = getQualifiedName(name); 292 Option option = options.getInHierarchy(qualifiedName); 293 Object result = null; 294 if (option != null) 295 { 296 result = option.getValue(); 297 } 298 return result; 299 } 300 301 /** 302 * Calculates the value of an option in the current outlet's context. 303 * The default namespace which is used when no namespace is given in 304 * <code>name</code> is the namespace of the currently used outlet. 305 * 306 * @param name the object containing the name of the option, 307 * which can contain a namespace, not null. 308 * 309 * @return The value of the option, or null if no option with that name 310 * is visible from the given namespace. 311 * 312 * @throws NullPointerException if optionName is null. 313 */ 314 public Object getOption(OptionName optionName) 315 { 316 return getOption(optionName.getName()); 317 } 318 319 /** 320 * Convenience method to return the value of an option as boolean. 321 * The option is evaluated in the current outlet's context, see 322 * getOption(String). <br/> 323 * Uses Boolean.paseBoolean() for String->Boolean conversion. 324 * @param name the name of the option, can contain a namespace. 325 * 326 * @return The value of the option as boolean, or false if no option 327 * with that name is visible from the given namespace, 328 */ 329 public boolean getBooleanOption(String name) 330 { 331 Object option = getOption(name); 332 if (option == null) 333 { 334 return false; 335 } 336 return Boolean.parseBoolean(option.toString()); 337 } 338 339 /** 340 * Convenience method to return the value of an option as boolean. 341 * The option is evaluated in the current outlet's context, see 342 * getOption(String). <br/> 343 * Uses Boolean.paseBoolean() for String->Boolean conversion. 344 * 345 * @param optionName the object containing the name of the option, 346 * which can contain a namespace. 347 * 348 * @return The value of the option as boolean, or false if no option 349 * with that name is visible from the given namespace. 350 * 351 * @throws NullPointerExeption if optionName is null. 352 */ 353 public boolean getBooleanOption(OptionName optionName) 354 { 355 return getBooleanOption(optionName.getName()); 356 } 357 358 /** 359 * Convenience method to return the value of an option as String. 360 * The option is evaluated in the current outlet's context, see 361 * getOption(String). <br/> 362 * 363 * @param name the name of the option, can contain a namespace. 364 * 365 * @return The value of the option as boolean, or false if no option 366 * with that name is visible from the given namespace, 367 */ 368 public String getStringOption(String name) 369 { 370 Object option = getOption(name); 371 if (option == null) 372 { 373 return null; 374 } 375 return option.toString(); 376 } 377 378 /** 379 * Convenience method to return the value of an option as String. 380 * The option is evaluated in the current outlet's context, see 381 * getOption(String). <br/> 382 * 383 * @param optionName the object containing the name of the option, 384 * which can contain a namespace. 385 * 386 * @return The value of the option as String, or null if no option 387 * with that name is visible from the given namespace, 388 * 389 * @throws NullPointerExeption if optionName is null. 390 */ 391 public String getStringOption(OptionName optionName) 392 { 393 return getStringOption(optionName.getName()); 394 } 395 396 /** 397 * Returns all options which are visible from the current outlet's 398 * namespace. 399 * 400 * @return all visible options, not null. 401 */ 402 public Options getVisibleOptions() 403 { 404 return unitConfiguration.getOptions().getInHierarchy( 405 outletNamespace); 406 } 407 408 /** 409 * Returns the VariableStore where generation variables can be set. 410 * 411 * @return the variableStore, never null. 412 */ 413 public VariableStore getVariableStore() 414 { 415 return variableStore; 416 } 417 418 /** 419 * Converts a name to a QualifiedName, using the outlet namespace as 420 * default namespace is fone is given. 421 * 422 * @param name the name to convert to a qualifiedName, not null. 423 * @return the corresponding qualifiedName. 424 * 425 * @throws NullPointerException if name is null 426 * @throws IllegalArgumentException if name is no valid qualifiedName. 427 */ 428 public QualifiedName getQualifiedName(String name) 429 { 430 QualifiedName qualifiedName = new QualifiedName( 431 name, 432 outletNamespace); 433 return qualifiedName; 434 } 435 436 /** 437 * Returns the currently generated file. 438 * 439 * @return the current output file. May only be null if no 440 * output file is currently generated (e.g. if the file name 441 * is currently generated). 442 */ 443 public File getOutputFile() 444 { 445 return outputFile; 446 } 447 448 /** 449 * Sets the currently generated file. 450 * 451 * @param outputFilePath the currently generated file, or null to remove 452 * the current output file. 453 */ 454 void setOutputFile(File outputFilePath) 455 { 456 this.outputFile = outputFilePath; 457 } 458 459 460 /** 461 * Returns the currently used source file. 462 * 463 * @return the current source file. May be null if no 464 * source file is currently used (e.g. if the source is created 465 * by other means than reading a file). 466 */ 467 public File getSourceFile() 468 { 469 return sourceFile; 470 } 471 472 /** 473 * Sets the currently used source file. 474 * 475 * @param sourceFile the current source file, or null to remove the 476 * source file. 477 */ 478 public void setSourceFile(File sourceFile) 479 { 480 this.sourceFile = sourceFile; 481 } 482 483 484 /** 485 * Returns the configuration of the currently processed generation unit. 486 * 487 * @return the configuration of the currently processed generation unit. 488 */ 489 public UnitConfiguration getUnitConfiguration() 490 { 491 return unitConfiguration; 492 } 493 494 /** 495 * Sets the configuration of the currently processed generation unit. 496 * 497 * @param unitConfiguration the configuration of the currently processed 498 * generation unit. 499 */ 500 public void setUnitConfiguration(UnitConfiguration unitConfiguration) 501 { 502 this.unitConfiguration = unitConfiguration; 503 } 504 505 @Override 506 public String toString() 507 { 508 StringBuffer result = new StringBuffer(); 509 result.append("sourceProvider=").append(sourceProvider) 510 .append("output=").append(output) 511 .append("outputFilePath=").append(outputFile) 512 .append("\noutletNamespace=").append(outletNamespace) 513 .append("\noutlets=").append(outlets) 514 .append("\nrootElement=").append(rootElement) 515 .append("\nsourceElement").append(sourceElement) 516 .append("\nrootOutletReference=") 517 .append(rootOutletReference) 518 .append("\nunitConfiguration=").append(unitConfiguration) 519 .append("\nvariableStore=").append(variableStore); 520 return result.toString(); 521 } 522 }