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