1 // license-header java merge-point 2 // 3 // Attention: generated code (by MetafacadeLogic.vsl) - do not modify! 4 // 5 package org.andromda.cartridges.bpm4struts.metafacades; 6 7 import java.util.Collection; 8 import java.util.List; 9 import org.andromda.core.common.Introspector; 10 import org.andromda.core.metafacade.MetafacadeBase; 11 import org.andromda.core.metafacade.MetafacadeFactory; 12 import org.andromda.core.metafacade.ModelValidationMessage; 13 import org.andromda.metafacades.uml.ActionFacade; 14 import org.andromda.metafacades.uml.ConstraintFacade; 15 import org.andromda.metafacades.uml.DependencyFacade; 16 import org.andromda.metafacades.uml.EventFacade; 17 import org.andromda.metafacades.uml.FrontEndAction; 18 import org.andromda.metafacades.uml.FrontEndActionState; 19 import org.andromda.metafacades.uml.FrontEndExceptionHandler; 20 import org.andromda.metafacades.uml.FrontEndForward; 21 import org.andromda.metafacades.uml.ModelElementFacade; 22 import org.andromda.metafacades.uml.ModelFacade; 23 import org.andromda.metafacades.uml.OperationFacade; 24 import org.andromda.metafacades.uml.PackageFacade; 25 import org.andromda.metafacades.uml.PartitionFacade; 26 import org.andromda.metafacades.uml.StateFacade; 27 import org.andromda.metafacades.uml.StateMachineFacade; 28 import org.andromda.metafacades.uml.StereotypeFacade; 29 import org.andromda.metafacades.uml.TaggedValueFacade; 30 import org.andromda.metafacades.uml.TemplateParameterFacade; 31 import org.andromda.metafacades.uml.TransitionFacade; 32 import org.andromda.metafacades.uml.TypeMappings; 33 34 /** 35 * A plain action state represents an operation on the server called by an action. Optionally an 36 * action state may defer operations to the controller. 37 * MetafacadeLogic for StrutsActionState 38 * 39 * @see StrutsActionState 40 */ 41 public abstract class StrutsActionStateLogic 42 extends MetafacadeBase 43 implements StrutsActionState 44 { 45 /** 46 * The underlying UML object 47 * @see Object 48 */ 49 protected Object metaObject; 50 51 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 52 * @param metaObjectIn 53 * @param context 54 */ 55 protected StrutsActionStateLogic(Object metaObjectIn, String context) 56 { 57 super(metaObjectIn, getContext(context)); 58 this.superFrontEndActionState = 59 (FrontEndActionState) 60 MetafacadeFactory.getInstance().createFacadeImpl( 61 "org.andromda.metafacades.uml.FrontEndActionState", 62 metaObjectIn, 63 getContext(context)); 64 this.metaObject = metaObjectIn; 65 } 66 67 /** 68 * Gets the context for this metafacade logic instance. 69 * @param context String. Set to StrutsActionState if null 70 * @return context String 71 */ 72 private static String getContext(String context) 73 { 74 if (context == null) 75 { 76 context = "org.andromda.cartridges.bpm4struts.metafacades.StrutsActionState"; 77 } 78 return context; 79 } 80 81 private FrontEndActionState superFrontEndActionState; 82 private boolean superFrontEndActionStateInitialized = false; 83 84 /** 85 * Gets the FrontEndActionState parent instance. 86 * @return this.superFrontEndActionState FrontEndActionState 87 */ 88 private FrontEndActionState getSuperFrontEndActionState() 89 { 90 if (!this.superFrontEndActionStateInitialized) 91 { 92 ((MetafacadeBase)this.superFrontEndActionState).setMetafacadeContext(this.getMetafacadeContext()); 93 this.superFrontEndActionStateInitialized = true; 94 } 95 return this.superFrontEndActionState; 96 } 97 98 /** Reset context only for non-root metafacades 99 * @param context 100 * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context) 101 */ 102 @Override 103 public void resetMetafacadeContext(String context) 104 { 105 if (!this.contextRoot) // reset context only for non-root metafacades 106 { 107 context = getContext(context); // to have same value as in original constructor call 108 setMetafacadeContext (context); 109 if (this.superFrontEndActionStateInitialized) 110 { 111 ((MetafacadeBase)this.superFrontEndActionState).resetMetafacadeContext(context); 112 } 113 } 114 } 115 116 /** 117 * @return boolean true always 118 * @see StrutsActionState 119 */ 120 public boolean isStrutsActionStateMetaType() 121 { 122 return true; 123 } 124 125 // ------------- associations ------------------ 126 127 /** 128 * @return true 129 * @see FrontEndActionState 130 */ 131 public boolean isFrontEndActionStateMetaType() 132 { 133 return true; 134 } 135 136 /** 137 * @return true 138 * @see org.andromda.metafacades.uml.ActionStateFacade 139 */ 140 public boolean isActionStateFacadeMetaType() 141 { 142 return true; 143 } 144 145 /** 146 * @return true 147 * @see StateFacade 148 */ 149 public boolean isStateFacadeMetaType() 150 { 151 return true; 152 } 153 154 /** 155 * @return true 156 * @see org.andromda.metafacades.uml.StateVertexFacade 157 */ 158 public boolean isStateVertexFacadeMetaType() 159 { 160 return true; 161 } 162 163 /** 164 * @return true 165 * @see ModelElementFacade 166 */ 167 public boolean isModelElementFacadeMetaType() 168 { 169 return true; 170 } 171 172 // ----------- delegates to FrontEndActionState ------------ 173 /** 174 * The entry action for this action state (if any). 175 * @see org.andromda.metafacades.uml.ActionStateFacade#getEntry() 176 */ 177 public ActionFacade getEntry() 178 { 179 return this.getSuperFrontEndActionState().getEntry(); 180 } 181 182 /** 183 * The method name representing this action state. 184 * @see FrontEndActionState#getActionMethodName() 185 */ 186 public String getActionMethodName() 187 { 188 return this.getSuperFrontEndActionState().getActionMethodName(); 189 } 190 191 /** 192 * The actions that pass through this action state. 193 * @see FrontEndActionState#getContainerActions() 194 */ 195 public List<FrontEndAction> getContainerActions() 196 { 197 return this.getSuperFrontEndActionState().getContainerActions(); 198 } 199 200 /** 201 * All calls deferred to the controller by this action state. 202 * @see FrontEndActionState#getControllerCalls() 203 */ 204 public List<OperationFacade> getControllerCalls() 205 { 206 return this.getSuperFrontEndActionState().getControllerCalls(); 207 } 208 209 /** 210 * All exceptions modelled on this action state. 211 * @see FrontEndActionState#getExceptions() 212 */ 213 public List<FrontEndExceptionHandler> getExceptions() 214 { 215 return this.getSuperFrontEndActionState().getExceptions(); 216 } 217 218 /** 219 * The next transition, there can be only one transition going out of an action state, otherwise 220 * decision points should be used (triggers are not supported at the server-side). 221 * @see FrontEndActionState#getForward() 222 */ 223 public FrontEndForward getForward() 224 { 225 return this.getSuperFrontEndActionState().getForward(); 226 } 227 228 /** 229 * All calls deferred to the services by this action state. 230 * @see FrontEndActionState#getServiceCalls() 231 */ 232 public List<OperationFacade> getServiceCalls() 233 { 234 return this.getSuperFrontEndActionState().getServiceCalls(); 235 } 236 237 /** 238 * True if this element is contained in a FrontEndUseCase. 239 * @see FrontEndActionState#isContainedInFrontEndUseCase() 240 */ 241 public boolean isContainedInFrontEndUseCase() 242 { 243 return this.getSuperFrontEndActionState().isContainedInFrontEndUseCase(); 244 } 245 246 /** 247 * Indicates whether or not this front end action state is server side. Pages, for example, are 248 * also action states but they return control to the client. 249 * @see FrontEndActionState#isServerSide() 250 */ 251 public boolean isServerSide() 252 { 253 return this.getSuperFrontEndActionState().isServerSide(); 254 } 255 256 /** 257 * Copies all tagged values from the given ModelElementFacade to this model element facade. 258 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 259 */ 260 public void copyTaggedValues(ModelElementFacade element) 261 { 262 this.getSuperFrontEndActionState().copyTaggedValues(element); 263 } 264 265 /** 266 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 267 * one found will be returned. 268 * @see ModelElementFacade#findTaggedValue(String tagName) 269 */ 270 public Object findTaggedValue(String tagName) 271 { 272 return this.getSuperFrontEndActionState().findTaggedValue(tagName); 273 } 274 275 /** 276 * Returns all the values for the tagged value with the specified name. The returned collection 277 * will contains only String instances, or will be empty. Never null. 278 * @see ModelElementFacade#findTaggedValues(String tagName) 279 */ 280 public Collection<Object> findTaggedValues(String tagName) 281 { 282 return this.getSuperFrontEndActionState().findTaggedValues(tagName); 283 } 284 285 /** 286 * Returns the fully qualified name of the model element. The fully qualified name includes 287 * complete package qualified name of the underlying model element. The templates parameter will 288 * be replaced by the correct one given the binding relation of the parameter to this element. 289 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 290 */ 291 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 292 { 293 return this.getSuperFrontEndActionState().getBindedFullyQualifiedName(bindedElement); 294 } 295 296 /** 297 * Gets all constraints belonging to the model element. 298 * @see ModelElementFacade#getConstraints() 299 */ 300 public Collection<ConstraintFacade> getConstraints() 301 { 302 return this.getSuperFrontEndActionState().getConstraints(); 303 } 304 305 /** 306 * Returns the constraints of the argument kind that have been placed onto this model. Typical 307 * kinds are "inv", "pre" and "post". Other kinds are possible. 308 * @see ModelElementFacade#getConstraints(String kind) 309 */ 310 public Collection<ConstraintFacade> getConstraints(String kind) 311 { 312 return this.getSuperFrontEndActionState().getConstraints(kind); 313 } 314 315 /** 316 * Gets the documentation for the model element, The indent argument is prefixed to each line. 317 * By default this method wraps lines after 64 characters. 318 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 319 * @see ModelElementFacade#getDocumentation(String indent) 320 */ 321 public String getDocumentation(String indent) 322 { 323 return this.getSuperFrontEndActionState().getDocumentation(indent); 324 } 325 326 /** 327 * This method returns the documentation for this model element, with the lines wrapped after 328 * the specified number of characters, values of less than 1 will indicate no line wrapping is 329 * required. By default paragraphs are returned as HTML. 330 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 331 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 332 */ 333 public String getDocumentation(String indent, int lineLength) 334 { 335 return this.getSuperFrontEndActionState().getDocumentation(indent, lineLength); 336 } 337 338 /** 339 * This method returns the documentation for this model element, with the lines wrapped after 340 * the specified number of characters, values of less than 1 will indicate no line wrapping is 341 * required. HTML style determines if HTML Escaping is applied. 342 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 343 */ 344 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 345 { 346 return this.getSuperFrontEndActionState().getDocumentation(indent, lineLength, htmlStyle); 347 } 348 349 /** 350 * The fully qualified name of this model element. 351 * @see ModelElementFacade#getFullyQualifiedName() 352 */ 353 public String getFullyQualifiedName() 354 { 355 return this.getSuperFrontEndActionState().getFullyQualifiedName(); 356 } 357 358 /** 359 * Returns the fully qualified name of the model element. The fully qualified name includes 360 * complete package qualified name of the underlying model element. If modelName is true, then 361 * the original name of the model element (the name contained within the model) will be the name 362 * returned, otherwise a name from a language mapping will be returned. 363 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 364 */ 365 public String getFullyQualifiedName(boolean modelName) 366 { 367 return this.getSuperFrontEndActionState().getFullyQualifiedName(modelName); 368 } 369 370 /** 371 * Returns the fully qualified name as a path, the returned value always starts with out a slash 372 * '/'. 373 * @see ModelElementFacade#getFullyQualifiedNamePath() 374 */ 375 public String getFullyQualifiedNamePath() 376 { 377 return this.getSuperFrontEndActionState().getFullyQualifiedNamePath(); 378 } 379 380 /** 381 * Gets the unique identifier of the underlying model element. 382 * @see ModelElementFacade#getId() 383 */ 384 public String getId() 385 { 386 return this.getSuperFrontEndActionState().getId(); 387 } 388 389 /** 390 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 391 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 392 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 393 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 394 * JDK5 compiler level. 395 * @see ModelElementFacade#getKeywords() 396 */ 397 public Collection<String> getKeywords() 398 { 399 return this.getSuperFrontEndActionState().getKeywords(); 400 } 401 402 /** 403 * UML2: Retrieves a localized label for this named element. 404 * @see ModelElementFacade#getLabel() 405 */ 406 public String getLabel() 407 { 408 return this.getSuperFrontEndActionState().getLabel(); 409 } 410 411 /** 412 * The language mappings that have been set for this model element. 413 * @see ModelElementFacade#getLanguageMappings() 414 */ 415 public TypeMappings getLanguageMappings() 416 { 417 return this.getSuperFrontEndActionState().getLanguageMappings(); 418 } 419 420 /** 421 * Return the model containing this model element (multiple models may be loaded and processed 422 * at the same time). 423 * @see ModelElementFacade#getModel() 424 */ 425 public ModelFacade getModel() 426 { 427 return this.getSuperFrontEndActionState().getModel(); 428 } 429 430 /** 431 * The name of the model element. 432 * @see ModelElementFacade#getName() 433 */ 434 public String getName() 435 { 436 return this.getSuperFrontEndActionState().getName(); 437 } 438 439 /** 440 * Gets the package to which this model element belongs. 441 * @see ModelElementFacade#getPackage() 442 */ 443 public ModelElementFacade getPackage() 444 { 445 return this.getSuperFrontEndActionState().getPackage(); 446 } 447 448 /** 449 * The name of this model element's package. 450 * @see ModelElementFacade#getPackageName() 451 */ 452 public String getPackageName() 453 { 454 return this.getSuperFrontEndActionState().getPackageName(); 455 } 456 457 /** 458 * Gets the package name (optionally providing the ability to retrieve the model name and not 459 * the mapped name). 460 * @see ModelElementFacade#getPackageName(boolean modelName) 461 */ 462 public String getPackageName(boolean modelName) 463 { 464 return this.getSuperFrontEndActionState().getPackageName(modelName); 465 } 466 467 /** 468 * Returns the package as a path, the returned value always starts with out a slash '/'. 469 * @see ModelElementFacade#getPackagePath() 470 */ 471 public String getPackagePath() 472 { 473 return this.getSuperFrontEndActionState().getPackagePath(); 474 } 475 476 /** 477 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 478 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 479 * the names of the containing namespaces starting at the root of the hierarchy and ending with 480 * the name of the NamedElement itself. 481 * @see ModelElementFacade#getQualifiedName() 482 */ 483 public String getQualifiedName() 484 { 485 return this.getSuperFrontEndActionState().getQualifiedName(); 486 } 487 488 /** 489 * Gets the root package for the model element. 490 * @see ModelElementFacade#getRootPackage() 491 */ 492 public PackageFacade getRootPackage() 493 { 494 return this.getSuperFrontEndActionState().getRootPackage(); 495 } 496 497 /** 498 * Gets the dependencies for which this model element is the source. 499 * @see ModelElementFacade#getSourceDependencies() 500 */ 501 public Collection<DependencyFacade> getSourceDependencies() 502 { 503 return this.getSuperFrontEndActionState().getSourceDependencies(); 504 } 505 506 /** 507 * If this model element is the context of an activity graph, this represents that activity 508 * graph. 509 * @see ModelElementFacade#getStateMachineContext() 510 */ 511 public StateMachineFacade getStateMachineContext() 512 { 513 return this.getSuperFrontEndActionState().getStateMachineContext(); 514 } 515 516 /** 517 * The collection of ALL stereotype names for this model element. 518 * @see ModelElementFacade#getStereotypeNames() 519 */ 520 public Collection<String> getStereotypeNames() 521 { 522 return this.getSuperFrontEndActionState().getStereotypeNames(); 523 } 524 525 /** 526 * Gets all stereotypes for this model element. 527 * @see ModelElementFacade#getStereotypes() 528 */ 529 public Collection<StereotypeFacade> getStereotypes() 530 { 531 return this.getSuperFrontEndActionState().getStereotypes(); 532 } 533 534 /** 535 * Return the TaggedValues associated with this model element, under all stereotypes. 536 * @see ModelElementFacade#getTaggedValues() 537 */ 538 public Collection<TaggedValueFacade> getTaggedValues() 539 { 540 return this.getSuperFrontEndActionState().getTaggedValues(); 541 } 542 543 /** 544 * Gets the dependencies for which this model element is the target. 545 * @see ModelElementFacade#getTargetDependencies() 546 */ 547 public Collection<DependencyFacade> getTargetDependencies() 548 { 549 return this.getSuperFrontEndActionState().getTargetDependencies(); 550 } 551 552 /** 553 * Get the template parameter for this model element having the parameterName 554 * @see ModelElementFacade#getTemplateParameter(String parameterName) 555 */ 556 public Object getTemplateParameter(String parameterName) 557 { 558 return this.getSuperFrontEndActionState().getTemplateParameter(parameterName); 559 } 560 561 /** 562 * Get the template parameters for this model element 563 * @see ModelElementFacade#getTemplateParameters() 564 */ 565 public Collection<TemplateParameterFacade> getTemplateParameters() 566 { 567 return this.getSuperFrontEndActionState().getTemplateParameters(); 568 } 569 570 /** 571 * The visibility (i.e. public, private, protected or package) of the model element, will 572 * attempt a lookup for these values in the language mappings (if any). 573 * @see ModelElementFacade#getVisibility() 574 */ 575 public String getVisibility() 576 { 577 return this.getSuperFrontEndActionState().getVisibility(); 578 } 579 580 /** 581 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 582 * is taken into account when searching for the stereotype), false otherwise. 583 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 584 */ 585 public boolean hasExactStereotype(String stereotypeName) 586 { 587 return this.getSuperFrontEndActionState().hasExactStereotype(stereotypeName); 588 } 589 590 /** 591 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 592 * pipe, semicolon, or << >> 593 * @see ModelElementFacade#hasKeyword(String keywordName) 594 */ 595 public boolean hasKeyword(String keywordName) 596 { 597 return this.getSuperFrontEndActionState().hasKeyword(keywordName); 598 } 599 600 /** 601 * Returns true if the model element has the specified stereotype. If the stereotype itself 602 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 603 * one of the stereotype's ancestors has a matching name this method will return true, false 604 * otherwise. 605 * For example, if we have a certain stereotype called <<exception>> and a model element has a 606 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 607 * method with 'stereotypeName' defined as 'exception' the method would return true since 608 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 609 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 610 * @see ModelElementFacade#hasStereotype(String stereotypeName) 611 */ 612 public boolean hasStereotype(String stereotypeName) 613 { 614 return this.getSuperFrontEndActionState().hasStereotype(stereotypeName); 615 } 616 617 /** 618 * True if there are target dependencies from this element that are instances of BindingFacade. 619 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 620 * @see ModelElementFacade#isBindingDependenciesPresent() 621 */ 622 public boolean isBindingDependenciesPresent() 623 { 624 return this.getSuperFrontEndActionState().isBindingDependenciesPresent(); 625 } 626 627 /** 628 * Indicates if any constraints are present on this model element. 629 * @see ModelElementFacade#isConstraintsPresent() 630 */ 631 public boolean isConstraintsPresent() 632 { 633 return this.getSuperFrontEndActionState().isConstraintsPresent(); 634 } 635 636 /** 637 * Indicates if any documentation is present on this model element. 638 * @see ModelElementFacade#isDocumentationPresent() 639 */ 640 public boolean isDocumentationPresent() 641 { 642 return this.getSuperFrontEndActionState().isDocumentationPresent(); 643 } 644 645 /** 646 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 647 * @see ModelElementFacade#isReservedWord() 648 */ 649 public boolean isReservedWord() 650 { 651 return this.getSuperFrontEndActionState().isReservedWord(); 652 } 653 654 /** 655 * True is there are template parameters on this model element. For UML2, applies to Class, 656 * Operation, Property, and Parameter. 657 * @see ModelElementFacade#isTemplateParametersPresent() 658 */ 659 public boolean isTemplateParametersPresent() 660 { 661 return this.getSuperFrontEndActionState().isTemplateParametersPresent(); 662 } 663 664 /** 665 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 666 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 667 * Enumerations and Interfaces, optionally applies on other model elements. 668 * @see ModelElementFacade#isValidIdentifierName() 669 */ 670 public boolean isValidIdentifierName() 671 { 672 return this.getSuperFrontEndActionState().isValidIdentifierName(); 673 } 674 675 /** 676 * Searches for the constraint with the specified 'name' on this model element, and if found 677 * translates it using the specified 'translation' from a translation library discovered by the 678 * framework. 679 * @see ModelElementFacade#translateConstraint(String name, String translation) 680 */ 681 public String translateConstraint(String name, String translation) 682 { 683 return this.getSuperFrontEndActionState().translateConstraint(name, translation); 684 } 685 686 /** 687 * Translates all constraints belonging to this model element with the given 'translation'. 688 * @see ModelElementFacade#translateConstraints(String translation) 689 */ 690 public String[] translateConstraints(String translation) 691 { 692 return this.getSuperFrontEndActionState().translateConstraints(translation); 693 } 694 695 /** 696 * Translates the constraints of the specified 'kind' belonging to this model element. 697 * @see ModelElementFacade#translateConstraints(String kind, String translation) 698 */ 699 public String[] translateConstraints(String kind, String translation) 700 { 701 return this.getSuperFrontEndActionState().translateConstraints(kind, translation); 702 } 703 704 /** 705 * Events to which is being deferred in this action state. 706 * @see StateFacade#getDeferrableEvents() 707 */ 708 public Collection<EventFacade> getDeferrableEvents() 709 { 710 return this.getSuperFrontEndActionState().getDeferrableEvents(); 711 } 712 713 /** 714 * Models a situation during which some (usually implicit) invariant condition holds. The states 715 * of 716 * protocol state machines are exposed to the users of their context classifiers. A protocol 717 * state 718 * represents an exposed stable situation of its context classifier: when an instance of the 719 * classifier 720 * is not processing any operation, users of this instance can always know its state 721 * configuration. 722 * @see org.andromda.metafacades.uml.StateVertexFacade#getContainer() 723 */ 724 public StateFacade getContainer() 725 { 726 return this.getSuperFrontEndActionState().getContainer(); 727 } 728 729 /** 730 * A directed relationship between a source vertex and a target vertex. It may be part of a 731 * compound 732 * transition, which takes the state machine from one state configuration to another, 733 * representing the 734 * complete response of the state machine to an occurrence of an event of a particular type. 735 * @see org.andromda.metafacades.uml.StateVertexFacade#getIncomings() 736 */ 737 public Collection<TransitionFacade> getIncomings() 738 { 739 return this.getSuperFrontEndActionState().getIncomings(); 740 } 741 742 /** 743 * A directed relationship between a source vertex and a target vertex. It may be part of a 744 * compound 745 * transition, which takes the state machine from one state configuration to another, 746 * representing the 747 * complete response of the state machine to an occurrence of an event of a particular type. 748 * @see org.andromda.metafacades.uml.StateVertexFacade#getOutgoings() 749 */ 750 public Collection<TransitionFacade> getOutgoings() 751 { 752 return this.getSuperFrontEndActionState().getOutgoings(); 753 } 754 755 /** 756 * The partition (if any) to which this vertex belongs. 757 * @see org.andromda.metafacades.uml.StateVertexFacade#getPartition() 758 */ 759 public PartitionFacade getPartition() 760 { 761 return this.getSuperFrontEndActionState().getPartition(); 762 } 763 764 /** 765 * State machines can be used to express the behavior of part of a system. Behavior is modeled 766 * as a 767 * traversal of a graph of state nodes interconnected by one or more joined transition arcs that 768 * are 769 * triggered by the dispatching of series of (event) occurrences. During this traversal, the 770 * state 771 * machine executes a series of activities associated with various elements of the state 772 * machine. 773 * @see org.andromda.metafacades.uml.StateVertexFacade#getStateMachine() 774 */ 775 public StateMachineFacade getStateMachine() 776 { 777 return this.getSuperFrontEndActionState().getStateMachine(); 778 } 779 780 /** 781 * @see org.andromda.core.metafacade.MetafacadeBase#initialize() 782 */ 783 @Override 784 public void initialize() 785 { 786 this.getSuperFrontEndActionState().initialize(); 787 } 788 789 /** 790 * @return Object getSuperFrontEndActionState().getValidationOwner() 791 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner() 792 */ 793 @Override 794 public Object getValidationOwner() 795 { 796 Object owner = this.getSuperFrontEndActionState().getValidationOwner(); 797 return owner; 798 } 799 800 /** 801 * @return String getSuperFrontEndActionState().getValidationName() 802 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName() 803 */ 804 @Override 805 public String getValidationName() 806 { 807 String name = this.getSuperFrontEndActionState().getValidationName(); 808 return name; 809 } 810 811 /** 812 * @param validationMessages Collection<ModelValidationMessage> 813 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages) 814 */ 815 @Override 816 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 817 { 818 this.getSuperFrontEndActionState().validateInvariants(validationMessages); 819 } 820 821 /** 822 * The property that stores the name of the metafacade. 823 */ 824 private static final String NAME_PROPERTY = "name"; 825 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 826 827 /** 828 * @see Object#toString() 829 */ 830 @Override 831 public String toString() 832 { 833 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 834 toString.append("["); 835 try 836 { 837 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 838 } 839 catch (final Throwable tryAgain) 840 { 841 try 842 { 843 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 844 } 845 catch (final Throwable ignore) 846 { 847 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 848 } 849 } 850 toString.append("]"); 851 return toString.toString(); 852 } 853 }