001// license-header java merge-point 002// 003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify! 004// 005package org.andromda.cartridges.hibernate.metafacades; 006 007import java.util.Collection; 008import java.util.List; 009import org.andromda.core.common.Introspector; 010import org.andromda.core.metafacade.MetafacadeBase; 011import org.andromda.core.metafacade.MetafacadeFactory; 012import org.andromda.core.metafacade.ModelValidationMessage; 013import org.andromda.metafacades.uml.AssociationEndFacade; 014import org.andromda.metafacades.uml.AttributeFacade; 015import org.andromda.metafacades.uml.ClassifierFacade; 016import org.andromda.metafacades.uml.ConstraintFacade; 017import org.andromda.metafacades.uml.DependencyFacade; 018import org.andromda.metafacades.uml.GeneralizableElementFacade; 019import org.andromda.metafacades.uml.GeneralizationFacade; 020import org.andromda.metafacades.uml.ModelElementFacade; 021import org.andromda.metafacades.uml.ModelFacade; 022import org.andromda.metafacades.uml.OperationFacade; 023import org.andromda.metafacades.uml.PackageFacade; 024import org.andromda.metafacades.uml.StateMachineFacade; 025import org.andromda.metafacades.uml.StereotypeFacade; 026import org.andromda.metafacades.uml.TaggedValueFacade; 027import org.andromda.metafacades.uml.TemplateParameterFacade; 028import org.andromda.metafacades.uml.TypeMappings; 029 030/** 031 * Represents an embedded object, a part of an entity. It behaves a lot like a HibernateEntity, has 032 * Attributes of type HibernateEntityAttribute, has BusinessOperations, but has no own identity. 033 * Most of the HibernateEntity templates are also used for this metafacade. 034 * MetafacadeLogic for HibernateEmbeddedValue 035 * 036 * @see HibernateEmbeddedValue 037 */ 038public abstract class HibernateEmbeddedValueLogic 039 extends MetafacadeBase 040 implements HibernateEmbeddedValue 041{ 042 /** 043 * The underlying UML object 044 * @see Object 045 */ 046 protected Object metaObject; 047 048 /** Create Metafacade implementation instance using the MetafacadeFactory from the context 049 * @param metaObjectIn 050 * @param context 051 */ 052 protected HibernateEmbeddedValueLogic(Object metaObjectIn, String context) 053 { 054 super(metaObjectIn, getContext(context)); 055 this.superClassifierFacade = 056 (ClassifierFacade) 057 MetafacadeFactory.getInstance().createFacadeImpl( 058 "org.andromda.metafacades.uml.ClassifierFacade", 059 metaObjectIn, 060 getContext(context)); 061 this.metaObject = metaObjectIn; 062 } 063 064 /** 065 * Gets the context for this metafacade logic instance. 066 * @param context String. Set to HibernateEmbeddedValue if null 067 * @return context String 068 */ 069 private static String getContext(String context) 070 { 071 if (context == null) 072 { 073 context = "org.andromda.cartridges.hibernate.metafacades.HibernateEmbeddedValue"; 074 } 075 return context; 076 } 077 078 private ClassifierFacade superClassifierFacade; 079 private boolean superClassifierFacadeInitialized = false; 080 081 /** 082 * Gets the ClassifierFacade parent instance. 083 * @return this.superClassifierFacade ClassifierFacade 084 */ 085 private ClassifierFacade getSuperClassifierFacade() 086 { 087 if (!this.superClassifierFacadeInitialized) 088 { 089 ((MetafacadeBase)this.superClassifierFacade).setMetafacadeContext(this.getMetafacadeContext()); 090 this.superClassifierFacadeInitialized = true; 091 } 092 return this.superClassifierFacade; 093 } 094 095 /** Reset context only for non-root metafacades 096 * @param context 097 * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context) 098 */ 099 @Override 100 public void resetMetafacadeContext(String context) 101 { 102 if (!this.contextRoot) // reset context only for non-root metafacades 103 { 104 context = getContext(context); // to have same value as in original constructor call 105 setMetafacadeContext (context); 106 if (this.superClassifierFacadeInitialized) 107 { 108 ((MetafacadeBase)this.superClassifierFacade).resetMetafacadeContext(context); 109 } 110 } 111 } 112 113 /** 114 * @return boolean true always 115 * @see HibernateEmbeddedValue 116 */ 117 public boolean isHibernateEmbeddedValueMetaType() 118 { 119 return true; 120 } 121 122 // --------------- attributes --------------------- 123 124 /** 125 * @see org.andromda.cartridges.hibernate.metafacades.HibernateEmbeddedValue#isImmutable() 126 * @return boolean 127 */ 128 protected abstract boolean handleIsImmutable(); 129 130 private boolean __immutable1a; 131 private boolean __immutable1aSet = false; 132 133 /** 134 * TODO: Model Documentation for 135 * org.andromda.cartridges.hibernate.metafacades.HibernateEmbeddedValue.immutable 136 * @return (boolean)handleIsImmutable() 137 */ 138 public final boolean isImmutable() 139 { 140 boolean immutable1a = this.__immutable1a; 141 if (!this.__immutable1aSet) 142 { 143 // immutable has no pre constraints 144 immutable1a = handleIsImmutable(); 145 // immutable has no post constraints 146 this.__immutable1a = immutable1a; 147 if (isMetafacadePropertyCachingEnabled()) 148 { 149 this.__immutable1aSet = true; 150 } 151 } 152 return immutable1a; 153 } 154 155 /** 156 * @see org.andromda.cartridges.hibernate.metafacades.HibernateEmbeddedValue#getImplementationName() 157 * @return String 158 */ 159 protected abstract String handleGetImplementationName(); 160 161 private String __implementationName2a; 162 private boolean __implementationName2aSet = false; 163 164 /** 165 * the name of the implementation class. 166 * @return (String)handleGetImplementationName() 167 */ 168 public final String getImplementationName() 169 { 170 String implementationName2a = this.__implementationName2a; 171 if (!this.__implementationName2aSet) 172 { 173 // implementationName has no pre constraints 174 implementationName2a = handleGetImplementationName(); 175 // implementationName has no post constraints 176 this.__implementationName2a = implementationName2a; 177 if (isMetafacadePropertyCachingEnabled()) 178 { 179 this.__implementationName2aSet = true; 180 } 181 } 182 return implementationName2a; 183 } 184 185 /** 186 * @return true 187 * @see ClassifierFacade 188 */ 189 public boolean isClassifierFacadeMetaType() 190 { 191 return true; 192 } 193 194 /** 195 * @return true 196 * @see GeneralizableElementFacade 197 */ 198 public boolean isGeneralizableElementFacadeMetaType() 199 { 200 return true; 201 } 202 203 /** 204 * @return true 205 * @see ModelElementFacade 206 */ 207 public boolean isModelElementFacadeMetaType() 208 { 209 return true; 210 } 211 212 // ----------- delegates to ClassifierFacade ------------ 213 /** 214 * Return the attribute which name matches the parameter 215 * @see ClassifierFacade#findAttribute(String name) 216 */ 217 public AttributeFacade findAttribute(String name) 218 { 219 return this.getSuperClassifierFacade().findAttribute(name); 220 } 221 222 /** 223 * Those abstraction dependencies for which this classifier is the client. 224 * @see ClassifierFacade#getAbstractions() 225 */ 226 public Collection<ClassifierFacade> getAbstractions() 227 { 228 return this.getSuperClassifierFacade().getAbstractions(); 229 } 230 231 /** 232 * Lists all classes associated to this one and any ancestor classes (through generalization). 233 * There will be no duplicates. The order of the elements is predictable. 234 * @see ClassifierFacade#getAllAssociatedClasses() 235 */ 236 public Collection<ClassifierFacade> getAllAssociatedClasses() 237 { 238 return this.getSuperClassifierFacade().getAllAssociatedClasses(); 239 } 240 241 /** 242 * A collection containing all 'properties' of the classifier and its ancestors. Properties are 243 * any attributes and navigable connecting association ends. 244 * @see ClassifierFacade#getAllProperties() 245 */ 246 public Collection<ModelElementFacade> getAllProperties() 247 { 248 return this.getSuperClassifierFacade().getAllProperties(); 249 } 250 251 /** 252 * A collection containing all required and/or read-only 'properties' of the classifier and its 253 * ancestors. Properties are any attributes and navigable connecting association ends. 254 * @see ClassifierFacade#getAllRequiredConstructorParameters() 255 */ 256 public Collection<ModelElementFacade> getAllRequiredConstructorParameters() 257 { 258 return this.getSuperClassifierFacade().getAllRequiredConstructorParameters(); 259 } 260 261 /** 262 * Gets the array type for this classifier. If this classifier already represents an array, it 263 * just returns itself. 264 * @see ClassifierFacade#getArray() 265 */ 266 public ClassifierFacade getArray() 267 { 268 return this.getSuperClassifierFacade().getArray(); 269 } 270 271 /** 272 * The name of the classifier as an array. 273 * @see ClassifierFacade#getArrayName() 274 */ 275 public String getArrayName() 276 { 277 return this.getSuperClassifierFacade().getArrayName(); 278 } 279 280 /** 281 * Lists the classes associated to this one, there is no repitition of classes. The order of the 282 * elements is predictable. 283 * @see ClassifierFacade#getAssociatedClasses() 284 */ 285 public Collection<ClassifierFacade> getAssociatedClasses() 286 { 287 return this.getSuperClassifierFacade().getAssociatedClasses(); 288 } 289 290 /** 291 * Gets the association ends belonging to a classifier. 292 * @see ClassifierFacade#getAssociationEnds() 293 */ 294 public List<AssociationEndFacade> getAssociationEnds() 295 { 296 return this.getSuperClassifierFacade().getAssociationEnds(); 297 } 298 299 /** 300 * Gets the attributes that belong to the classifier. 301 * @see ClassifierFacade#getAttributes() 302 */ 303 public List<AttributeFacade> getAttributes() 304 { 305 return this.getSuperClassifierFacade().getAttributes(); 306 } 307 308 /** 309 * Gets all attributes for the classifier and if 'follow' is true goes up the inheritance 310 * hierarchy and gets the attributes from the super classes as well. 311 * @see ClassifierFacade#getAttributes(boolean follow) 312 */ 313 public List<AttributeFacade> getAttributes(boolean follow) 314 { 315 return this.getSuperClassifierFacade().getAttributes(follow); 316 } 317 318 /** 319 * The fully qualified name of the classifier as an array. 320 * @see ClassifierFacade#getFullyQualifiedArrayName() 321 */ 322 public String getFullyQualifiedArrayName() 323 { 324 return this.getSuperClassifierFacade().getFullyQualifiedArrayName(); 325 } 326 327 /** 328 * Returns all those operations that could be implemented at this classifier's level. This means 329 * the operations owned by this classifier as well as any realized interface's operations 330 * (recursively) in case this classifier itself is not already an interface, or generalized when 331 * this classifier is an interface. 332 * @see ClassifierFacade#getImplementationOperations() 333 */ 334 public Collection<OperationFacade> getImplementationOperations() 335 { 336 return this.getSuperClassifierFacade().getImplementationOperations(); 337 } 338 339 /** 340 * A comma separated list of the fully qualified names of all implemented interfaces. 341 * @see ClassifierFacade#getImplementedInterfaceList() 342 */ 343 public String getImplementedInterfaceList() 344 { 345 return this.getSuperClassifierFacade().getImplementedInterfaceList(); 346 } 347 348 /** 349 * Those attributes that are scoped to an instance of this class. 350 * @see ClassifierFacade#getInstanceAttributes() 351 */ 352 public Collection<AttributeFacade> getInstanceAttributes() 353 { 354 return this.getSuperClassifierFacade().getInstanceAttributes(); 355 } 356 357 /** 358 * Those operations that are scoped to an instance of this class. 359 * @see ClassifierFacade#getInstanceOperations() 360 */ 361 public List<OperationFacade> getInstanceOperations() 362 { 363 return this.getSuperClassifierFacade().getInstanceOperations(); 364 } 365 366 /** 367 * Those interfaces that are abstractions of this classifier, this basically means this 368 * classifier realizes them. 369 * @see ClassifierFacade#getInterfaceAbstractions() 370 */ 371 public Collection<ClassifierFacade> getInterfaceAbstractions() 372 { 373 return this.getSuperClassifierFacade().getInterfaceAbstractions(); 374 } 375 376 /** 377 * A String representing a new Constructor declaration for this classifier type to be used in a 378 * Java environment. 379 * @see ClassifierFacade#getJavaNewString() 380 */ 381 public String getJavaNewString() 382 { 383 return this.getSuperClassifierFacade().getJavaNewString(); 384 } 385 386 /** 387 * A String representing the null-value for this classifier type to be used in a Java 388 * environment. 389 * @see ClassifierFacade#getJavaNullString() 390 */ 391 public String getJavaNullString() 392 { 393 return this.getSuperClassifierFacade().getJavaNullString(); 394 } 395 396 /** 397 * The other ends of this classifier's association ends which are navigable. 398 * @see ClassifierFacade#getNavigableConnectingEnds() 399 */ 400 public Collection<AssociationEndFacade> getNavigableConnectingEnds() 401 { 402 return this.getSuperClassifierFacade().getNavigableConnectingEnds(); 403 } 404 405 /** 406 * Get the other ends of this classifier's association ends which are navigable and if 'follow' 407 * is true goes up the inheritance hierarchy and gets the super association ends as well. 408 * @see ClassifierFacade#getNavigableConnectingEnds(boolean follow) 409 */ 410 public List<AssociationEndFacade> getNavigableConnectingEnds(boolean follow) 411 { 412 return this.getSuperClassifierFacade().getNavigableConnectingEnds(follow); 413 } 414 415 /** 416 * Assuming that the classifier is an array, this will return the non array type of the 417 * classifier from 418 * the model. If the classifier is NOT an array, it will just return itself. 419 * @see ClassifierFacade#getNonArray() 420 */ 421 public ClassifierFacade getNonArray() 422 { 423 return this.getSuperClassifierFacade().getNonArray(); 424 } 425 426 /** 427 * The attributes from this classifier in the form of an operation call (this example would be 428 * in Java): '(String attributeOne, String attributeTwo). If there were no attributes on the 429 * classifier, the result would be an empty '()'. 430 * @see ClassifierFacade#getOperationCallFromAttributes() 431 */ 432 public String getOperationCallFromAttributes() 433 { 434 return this.getSuperClassifierFacade().getOperationCallFromAttributes(); 435 } 436 437 /** 438 * The operations owned by this classifier. 439 * @see ClassifierFacade#getOperations() 440 */ 441 public List<OperationFacade> getOperations() 442 { 443 return this.getSuperClassifierFacade().getOperations(); 444 } 445 446 /** 447 * A collection containing all 'properties' of the classifier. Properties are any attributes 448 * and navigable connecting association ends. 449 * @see ClassifierFacade#getProperties() 450 */ 451 public List<ModelElementFacade> getProperties() 452 { 453 return this.getSuperClassifierFacade().getProperties(); 454 } 455 456 /** 457 * Gets all properties (attributes and navigable association ends) for the classifier and if 458 * 'follow' is true goes up the inheritance hierarchy and gets the properties from the super 459 * classes as well. 460 * @see ClassifierFacade#getProperties(boolean follow) 461 */ 462 public List getProperties(boolean follow) 463 { 464 return this.getSuperClassifierFacade().getProperties(follow); 465 } 466 467 /** 468 * A collection containing all required and/or read-only 'properties' of the classifier. 469 * Properties are any attributes and navigable connecting association ends. 470 * @see ClassifierFacade#getRequiredConstructorParameters() 471 */ 472 public Collection<ModelElementFacade> getRequiredConstructorParameters() 473 { 474 return this.getSuperClassifierFacade().getRequiredConstructorParameters(); 475 } 476 477 /** 478 * Returns the serial version UID of the underlying model element. 479 * @see ClassifierFacade#getSerialVersionUID() 480 */ 481 public long getSerialVersionUID() 482 { 483 return this.getSuperClassifierFacade().getSerialVersionUID(); 484 } 485 486 /** 487 * Those attributes that are scoped to the definition of this class. 488 * @see ClassifierFacade#getStaticAttributes() 489 */ 490 public Collection<AttributeFacade> getStaticAttributes() 491 { 492 return this.getSuperClassifierFacade().getStaticAttributes(); 493 } 494 495 /** 496 * Those operations that are scoped to the definition of this class. 497 * @see ClassifierFacade#getStaticOperations() 498 */ 499 public List<OperationFacade> getStaticOperations() 500 { 501 return this.getSuperClassifierFacade().getStaticOperations(); 502 } 503 504 /** 505 * This class' superclass, returns the generalization if it is a ClassifierFacade, null 506 * otherwise. 507 * @see ClassifierFacade#getSuperClass() 508 */ 509 public ClassifierFacade getSuperClass() 510 { 511 return this.getSuperClassifierFacade().getSuperClass(); 512 } 513 514 /** 515 * The wrapper name for this classifier if a mapped type has a defined wrapper class (ie. 'long' 516 * maps to 'Long'). If the classifier doesn't have a wrapper defined for it, this method will 517 * return a null. Note that wrapper mappings must be defined for the namespace by defining the 518 * 'wrapperMappingsUri', this property must point to the location of the mappings file which 519 * maps the primitives to wrapper types. 520 * @see ClassifierFacade#getWrapperName() 521 */ 522 public String getWrapperName() 523 { 524 return this.getSuperClassifierFacade().getWrapperName(); 525 } 526 527 /** 528 * Indicates if this classifier is 'abstract'. 529 * @see ClassifierFacade#isAbstract() 530 */ 531 public boolean isAbstract() 532 { 533 return this.getSuperClassifierFacade().isAbstract(); 534 } 535 536 /** 537 * True if this classifier represents an array type. False otherwise. 538 * @see ClassifierFacade#isArrayType() 539 */ 540 public boolean isArrayType() 541 { 542 return this.getSuperClassifierFacade().isArrayType(); 543 } 544 545 /** 546 * True if the ClassifierFacade is an AssociationClass. 547 * @see ClassifierFacade#isAssociationClass() 548 */ 549 public boolean isAssociationClass() 550 { 551 return this.getSuperClassifierFacade().isAssociationClass(); 552 } 553 554 /** 555 * Returns true if this type represents a Blob type. 556 * @see ClassifierFacade#isBlobType() 557 */ 558 public boolean isBlobType() 559 { 560 return this.getSuperClassifierFacade().isBlobType(); 561 } 562 563 /** 564 * Indicates if this type represents a boolean type or not. 565 * @see ClassifierFacade#isBooleanType() 566 */ 567 public boolean isBooleanType() 568 { 569 return this.getSuperClassifierFacade().isBooleanType(); 570 } 571 572 /** 573 * Indicates if this type represents a char, Character, or java.lang.Character type or not. 574 * @see ClassifierFacade#isCharacterType() 575 */ 576 public boolean isCharacterType() 577 { 578 return this.getSuperClassifierFacade().isCharacterType(); 579 } 580 581 /** 582 * Returns true if this type represents a Clob type. 583 * @see ClassifierFacade#isClobType() 584 */ 585 public boolean isClobType() 586 { 587 return this.getSuperClassifierFacade().isClobType(); 588 } 589 590 /** 591 * True if this classifier represents a collection type. False otherwise. 592 * @see ClassifierFacade#isCollectionType() 593 */ 594 public boolean isCollectionType() 595 { 596 return this.getSuperClassifierFacade().isCollectionType(); 597 } 598 599 /** 600 * True/false depending on whether or not this classifier represents a datatype. A data type is 601 * a type whose instances are identified only by their value. A data type may contain attributes 602 * to support the modeling of structured data types. 603 * @see ClassifierFacade#isDataType() 604 */ 605 public boolean isDataType() 606 { 607 return this.getSuperClassifierFacade().isDataType(); 608 } 609 610 /** 611 * True when this classifier is a date type. 612 * @see ClassifierFacade#isDateType() 613 */ 614 public boolean isDateType() 615 { 616 return this.getSuperClassifierFacade().isDateType(); 617 } 618 619 /** 620 * Indicates if this type represents a Double type or not. 621 * @see ClassifierFacade#isDoubleType() 622 */ 623 public boolean isDoubleType() 624 { 625 return this.getSuperClassifierFacade().isDoubleType(); 626 } 627 628 /** 629 * Indicates whether or not this classifier represents an "EmbeddedValue'. 630 * @see ClassifierFacade#isEmbeddedValue() 631 */ 632 public boolean isEmbeddedValue() 633 { 634 return this.getSuperClassifierFacade().isEmbeddedValue(); 635 } 636 637 /** 638 * True if this classifier is in fact marked as an enumeration. 639 * @see ClassifierFacade#isEnumeration() 640 */ 641 public boolean isEnumeration() 642 { 643 return this.getSuperClassifierFacade().isEnumeration(); 644 } 645 646 /** 647 * Returns true if this type represents a 'file' type. 648 * @see ClassifierFacade#isFileType() 649 */ 650 public boolean isFileType() 651 { 652 return this.getSuperClassifierFacade().isFileType(); 653 } 654 655 /** 656 * Indicates if this type represents a Float type or not. 657 * @see ClassifierFacade#isFloatType() 658 */ 659 public boolean isFloatType() 660 { 661 return this.getSuperClassifierFacade().isFloatType(); 662 } 663 664 /** 665 * Indicates if this type represents an int or Integer or java.lang.Integer type or not. 666 * @see ClassifierFacade#isIntegerType() 667 */ 668 public boolean isIntegerType() 669 { 670 return this.getSuperClassifierFacade().isIntegerType(); 671 } 672 673 /** 674 * True/false depending on whether or not this Classifier represents an interface. 675 * @see ClassifierFacade#isInterface() 676 */ 677 public boolean isInterface() 678 { 679 return this.getSuperClassifierFacade().isInterface(); 680 } 681 682 /** 683 * True if this classifier cannot be extended and represent a leaf in the inheritance tree. 684 * @see ClassifierFacade#isLeaf() 685 */ 686 public boolean isLeaf() 687 { 688 return this.getSuperClassifierFacade().isLeaf(); 689 } 690 691 /** 692 * True if this classifier represents a list type. False otherwise. 693 * @see ClassifierFacade#isListType() 694 */ 695 public boolean isListType() 696 { 697 return this.getSuperClassifierFacade().isListType(); 698 } 699 700 /** 701 * Indicates if this type represents a Long type or not. 702 * @see ClassifierFacade#isLongType() 703 */ 704 public boolean isLongType() 705 { 706 return this.getSuperClassifierFacade().isLongType(); 707 } 708 709 /** 710 * Indicates whether or not this classifier represents a Map type. 711 * @see ClassifierFacade#isMapType() 712 */ 713 public boolean isMapType() 714 { 715 return this.getSuperClassifierFacade().isMapType(); 716 } 717 718 /** 719 * Indicates whether or not this classifier represents a primitive type. 720 * @see ClassifierFacade#isPrimitive() 721 */ 722 public boolean isPrimitive() 723 { 724 return this.getSuperClassifierFacade().isPrimitive(); 725 } 726 727 /** 728 * True if this classifier represents a set type. False otherwise. 729 * @see ClassifierFacade#isSetType() 730 */ 731 public boolean isSetType() 732 { 733 return this.getSuperClassifierFacade().isSetType(); 734 } 735 736 /** 737 * Indicates whether or not this classifier represents a string type. 738 * @see ClassifierFacade#isStringType() 739 */ 740 public boolean isStringType() 741 { 742 return this.getSuperClassifierFacade().isStringType(); 743 } 744 745 /** 746 * Indicates whether or not this classifier represents a time type. 747 * @see ClassifierFacade#isTimeType() 748 */ 749 public boolean isTimeType() 750 { 751 return this.getSuperClassifierFacade().isTimeType(); 752 } 753 754 /** 755 * Returns true if this type is a wrapped primitive type. 756 * @see ClassifierFacade#isWrappedPrimitive() 757 */ 758 public boolean isWrappedPrimitive() 759 { 760 return this.getSuperClassifierFacade().isWrappedPrimitive(); 761 } 762 763 /** 764 * Finds the tagged value optional searching the entire inheritance hierarchy if 'follow' is set 765 * to true. 766 * @see GeneralizableElementFacade#findTaggedValue(String tagName, boolean follow) 767 */ 768 public Object findTaggedValue(String tagName, boolean follow) 769 { 770 return this.getSuperClassifierFacade().findTaggedValue(tagName, follow); 771 } 772 773 /** 774 * All generalizations for this generalizable element, goes up the inheritance tree. 775 * @see GeneralizableElementFacade#getAllGeneralizations() 776 */ 777 public Collection<GeneralizableElementFacade> getAllGeneralizations() 778 { 779 return this.getSuperClassifierFacade().getAllGeneralizations(); 780 } 781 782 /** 783 * All specializations (travels down the inheritance hierarchy). 784 * @see GeneralizableElementFacade#getAllSpecializations() 785 */ 786 public Collection<GeneralizableElementFacade> getAllSpecializations() 787 { 788 return this.getSuperClassifierFacade().getAllSpecializations(); 789 } 790 791 /** 792 * Gets the direct generalization for this generalizable element. 793 * @see GeneralizableElementFacade#getGeneralization() 794 */ 795 public GeneralizableElementFacade getGeneralization() 796 { 797 return this.getSuperClassifierFacade().getGeneralization(); 798 } 799 800 /** 801 * Gets the actual links that this generalization element is part of (it plays either the 802 * specialization or generalization). 803 * @see GeneralizableElementFacade#getGeneralizationLinks() 804 */ 805 public Collection<GeneralizationFacade> getGeneralizationLinks() 806 { 807 return this.getSuperClassifierFacade().getGeneralizationLinks(); 808 } 809 810 /** 811 * A comma separated list of the fully qualified names of all generalizations. 812 * @see GeneralizableElementFacade#getGeneralizationList() 813 */ 814 public String getGeneralizationList() 815 { 816 return this.getSuperClassifierFacade().getGeneralizationList(); 817 } 818 819 /** 820 * The element found when you recursively follow the generalization path up to the root. If an 821 * element has no generalization itself will be considered the root. 822 * @see GeneralizableElementFacade#getGeneralizationRoot() 823 */ 824 public GeneralizableElementFacade getGeneralizationRoot() 825 { 826 return this.getSuperClassifierFacade().getGeneralizationRoot(); 827 } 828 829 /** 830 * Return all generalizations (ancestors) from this generalizable element. 831 * @see GeneralizableElementFacade#getGeneralizations() 832 */ 833 public Collection<GeneralizableElementFacade> getGeneralizations() 834 { 835 return this.getSuperClassifierFacade().getGeneralizations(); 836 } 837 838 /** 839 * Gets the direct specializations (i.e. sub elements) for this generalizatble element. 840 * @see GeneralizableElementFacade#getSpecializations() 841 */ 842 public Collection<GeneralizableElementFacade> getSpecializations() 843 { 844 return this.getSuperClassifierFacade().getSpecializations(); 845 } 846 847 /** 848 * Copies all tagged values from the given ModelElementFacade to this model element facade. 849 * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element) 850 */ 851 public void copyTaggedValues(ModelElementFacade element) 852 { 853 this.getSuperClassifierFacade().copyTaggedValues(element); 854 } 855 856 /** 857 * Finds the tagged value with the specified 'tagName'. In case there are more values the first 858 * one found will be returned. 859 * @see ModelElementFacade#findTaggedValue(String tagName) 860 */ 861 public Object findTaggedValue(String tagName) 862 { 863 return this.getSuperClassifierFacade().findTaggedValue(tagName); 864 } 865 866 /** 867 * Returns all the values for the tagged value with the specified name. The returned collection 868 * will contains only String instances, or will be empty. Never null. 869 * @see ModelElementFacade#findTaggedValues(String tagName) 870 */ 871 public Collection<Object> findTaggedValues(String tagName) 872 { 873 return this.getSuperClassifierFacade().findTaggedValues(tagName); 874 } 875 876 /** 877 * Returns the fully qualified name of the model element. The fully qualified name includes 878 * complete package qualified name of the underlying model element. The templates parameter will 879 * be replaced by the correct one given the binding relation of the parameter to this element. 880 * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement) 881 */ 882 public String getBindedFullyQualifiedName(ModelElementFacade bindedElement) 883 { 884 return this.getSuperClassifierFacade().getBindedFullyQualifiedName(bindedElement); 885 } 886 887 /** 888 * Gets all constraints belonging to the model element. 889 * @see ModelElementFacade#getConstraints() 890 */ 891 public Collection<ConstraintFacade> getConstraints() 892 { 893 return this.getSuperClassifierFacade().getConstraints(); 894 } 895 896 /** 897 * Returns the constraints of the argument kind that have been placed onto this model. Typical 898 * kinds are "inv", "pre" and "post". Other kinds are possible. 899 * @see ModelElementFacade#getConstraints(String kind) 900 */ 901 public Collection<ConstraintFacade> getConstraints(String kind) 902 { 903 return this.getSuperClassifierFacade().getConstraints(kind); 904 } 905 906 /** 907 * Gets the documentation for the model element, The indent argument is prefixed to each line. 908 * By default this method wraps lines after 64 characters. 909 * This method is equivalent to <code>getDocumentation(indent, 64)</code>. 910 * @see ModelElementFacade#getDocumentation(String indent) 911 */ 912 public String getDocumentation(String indent) 913 { 914 return this.getSuperClassifierFacade().getDocumentation(indent); 915 } 916 917 /** 918 * This method returns the documentation for this model element, with the lines wrapped after 919 * the specified number of characters, values of less than 1 will indicate no line wrapping is 920 * required. By default paragraphs are returned as HTML. 921 * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>. 922 * @see ModelElementFacade#getDocumentation(String indent, int lineLength) 923 */ 924 public String getDocumentation(String indent, int lineLength) 925 { 926 return this.getSuperClassifierFacade().getDocumentation(indent, lineLength); 927 } 928 929 /** 930 * This method returns the documentation for this model element, with the lines wrapped after 931 * the specified number of characters, values of less than 1 will indicate no line wrapping is 932 * required. HTML style determines if HTML Escaping is applied. 933 * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle) 934 */ 935 public String getDocumentation(String indent, int lineLength, boolean htmlStyle) 936 { 937 return this.getSuperClassifierFacade().getDocumentation(indent, lineLength, htmlStyle); 938 } 939 940 /** 941 * The fully qualified name of this model element. 942 * @see ModelElementFacade#getFullyQualifiedName() 943 */ 944 public String getFullyQualifiedName() 945 { 946 return this.getSuperClassifierFacade().getFullyQualifiedName(); 947 } 948 949 /** 950 * Returns the fully qualified name of the model element. The fully qualified name includes 951 * complete package qualified name of the underlying model element. If modelName is true, then 952 * the original name of the model element (the name contained within the model) will be the name 953 * returned, otherwise a name from a language mapping will be returned. 954 * @see ModelElementFacade#getFullyQualifiedName(boolean modelName) 955 */ 956 public String getFullyQualifiedName(boolean modelName) 957 { 958 return this.getSuperClassifierFacade().getFullyQualifiedName(modelName); 959 } 960 961 /** 962 * Returns the fully qualified name as a path, the returned value always starts with out a slash 963 * '/'. 964 * @see ModelElementFacade#getFullyQualifiedNamePath() 965 */ 966 public String getFullyQualifiedNamePath() 967 { 968 return this.getSuperClassifierFacade().getFullyQualifiedNamePath(); 969 } 970 971 /** 972 * Gets the unique identifier of the underlying model element. 973 * @see ModelElementFacade#getId() 974 */ 975 public String getId() 976 { 977 return this.getSuperClassifierFacade().getId(); 978 } 979 980 /** 981 * UML2: Retrieves the keywords for this element. Used to modify implementation properties which 982 * are not represented by other properties, i.e. native, transient, volatile, synchronized, 983 * (added annotations) override, deprecated. Can also be used to suppress compiler warnings: 984 * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require 985 * JDK5 compiler level. 986 * @see ModelElementFacade#getKeywords() 987 */ 988 public Collection<String> getKeywords() 989 { 990 return this.getSuperClassifierFacade().getKeywords(); 991 } 992 993 /** 994 * UML2: Retrieves a localized label for this named element. 995 * @see ModelElementFacade#getLabel() 996 */ 997 public String getLabel() 998 { 999 return this.getSuperClassifierFacade().getLabel(); 1000 } 1001 1002 /** 1003 * The language mappings that have been set for this model element. 1004 * @see ModelElementFacade#getLanguageMappings() 1005 */ 1006 public TypeMappings getLanguageMappings() 1007 { 1008 return this.getSuperClassifierFacade().getLanguageMappings(); 1009 } 1010 1011 /** 1012 * Return the model containing this model element (multiple models may be loaded and processed 1013 * at the same time). 1014 * @see ModelElementFacade#getModel() 1015 */ 1016 public ModelFacade getModel() 1017 { 1018 return this.getSuperClassifierFacade().getModel(); 1019 } 1020 1021 /** 1022 * The name of the model element. 1023 * @see ModelElementFacade#getName() 1024 */ 1025 public String getName() 1026 { 1027 return this.getSuperClassifierFacade().getName(); 1028 } 1029 1030 /** 1031 * Gets the package to which this model element belongs. 1032 * @see ModelElementFacade#getPackage() 1033 */ 1034 public ModelElementFacade getPackage() 1035 { 1036 return this.getSuperClassifierFacade().getPackage(); 1037 } 1038 1039 /** 1040 * The name of this model element's package. 1041 * @see ModelElementFacade#getPackageName() 1042 */ 1043 public String getPackageName() 1044 { 1045 return this.getSuperClassifierFacade().getPackageName(); 1046 } 1047 1048 /** 1049 * Gets the package name (optionally providing the ability to retrieve the model name and not 1050 * the mapped name). 1051 * @see ModelElementFacade#getPackageName(boolean modelName) 1052 */ 1053 public String getPackageName(boolean modelName) 1054 { 1055 return this.getSuperClassifierFacade().getPackageName(modelName); 1056 } 1057 1058 /** 1059 * Returns the package as a path, the returned value always starts with out a slash '/'. 1060 * @see ModelElementFacade#getPackagePath() 1061 */ 1062 public String getPackagePath() 1063 { 1064 return this.getSuperClassifierFacade().getPackagePath(); 1065 } 1066 1067 /** 1068 * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the 1069 * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from 1070 * the names of the containing namespaces starting at the root of the hierarchy and ending with 1071 * the name of the NamedElement itself. 1072 * @see ModelElementFacade#getQualifiedName() 1073 */ 1074 public String getQualifiedName() 1075 { 1076 return this.getSuperClassifierFacade().getQualifiedName(); 1077 } 1078 1079 /** 1080 * Gets the root package for the model element. 1081 * @see ModelElementFacade#getRootPackage() 1082 */ 1083 public PackageFacade getRootPackage() 1084 { 1085 return this.getSuperClassifierFacade().getRootPackage(); 1086 } 1087 1088 /** 1089 * Gets the dependencies for which this model element is the source. 1090 * @see ModelElementFacade#getSourceDependencies() 1091 */ 1092 public Collection<DependencyFacade> getSourceDependencies() 1093 { 1094 return this.getSuperClassifierFacade().getSourceDependencies(); 1095 } 1096 1097 /** 1098 * If this model element is the context of an activity graph, this represents that activity 1099 * graph. 1100 * @see ModelElementFacade#getStateMachineContext() 1101 */ 1102 public StateMachineFacade getStateMachineContext() 1103 { 1104 return this.getSuperClassifierFacade().getStateMachineContext(); 1105 } 1106 1107 /** 1108 * The collection of ALL stereotype names for this model element. 1109 * @see ModelElementFacade#getStereotypeNames() 1110 */ 1111 public Collection<String> getStereotypeNames() 1112 { 1113 return this.getSuperClassifierFacade().getStereotypeNames(); 1114 } 1115 1116 /** 1117 * Gets all stereotypes for this model element. 1118 * @see ModelElementFacade#getStereotypes() 1119 */ 1120 public Collection<StereotypeFacade> getStereotypes() 1121 { 1122 return this.getSuperClassifierFacade().getStereotypes(); 1123 } 1124 1125 /** 1126 * Return the TaggedValues associated with this model element, under all stereotypes. 1127 * @see ModelElementFacade#getTaggedValues() 1128 */ 1129 public Collection<TaggedValueFacade> getTaggedValues() 1130 { 1131 return this.getSuperClassifierFacade().getTaggedValues(); 1132 } 1133 1134 /** 1135 * Gets the dependencies for which this model element is the target. 1136 * @see ModelElementFacade#getTargetDependencies() 1137 */ 1138 public Collection<DependencyFacade> getTargetDependencies() 1139 { 1140 return this.getSuperClassifierFacade().getTargetDependencies(); 1141 } 1142 1143 /** 1144 * Get the template parameter for this model element having the parameterName 1145 * @see ModelElementFacade#getTemplateParameter(String parameterName) 1146 */ 1147 public Object getTemplateParameter(String parameterName) 1148 { 1149 return this.getSuperClassifierFacade().getTemplateParameter(parameterName); 1150 } 1151 1152 /** 1153 * Get the template parameters for this model element 1154 * @see ModelElementFacade#getTemplateParameters() 1155 */ 1156 public Collection<TemplateParameterFacade> getTemplateParameters() 1157 { 1158 return this.getSuperClassifierFacade().getTemplateParameters(); 1159 } 1160 1161 /** 1162 * The visibility (i.e. public, private, protected or package) of the model element, will 1163 * attempt a lookup for these values in the language mappings (if any). 1164 * @see ModelElementFacade#getVisibility() 1165 */ 1166 public String getVisibility() 1167 { 1168 return this.getSuperClassifierFacade().getVisibility(); 1169 } 1170 1171 /** 1172 * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance 1173 * is taken into account when searching for the stereotype), false otherwise. 1174 * @see ModelElementFacade#hasExactStereotype(String stereotypeName) 1175 */ 1176 public boolean hasExactStereotype(String stereotypeName) 1177 { 1178 return this.getSuperClassifierFacade().hasExactStereotype(stereotypeName); 1179 } 1180 1181 /** 1182 * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma, 1183 * pipe, semicolon, or << >> 1184 * @see ModelElementFacade#hasKeyword(String keywordName) 1185 */ 1186 public boolean hasKeyword(String keywordName) 1187 { 1188 return this.getSuperClassifierFacade().hasKeyword(keywordName); 1189 } 1190 1191 /** 1192 * Returns true if the model element has the specified stereotype. If the stereotype itself 1193 * does not match, then a search will be made up the stereotype inheritance hierarchy, and if 1194 * one of the stereotype's ancestors has a matching name this method will return true, false 1195 * otherwise. 1196 * For example, if we have a certain stereotype called <<exception>> and a model element has a 1197 * stereotype called <<applicationException>> which extends <<exception>>, when calling this 1198 * method with 'stereotypeName' defined as 'exception' the method would return true since 1199 * <<applicationException>> inherits from <<exception>>. If you want to check if the model 1200 * element has the exact stereotype, then use the method 'hasExactStereotype' instead. 1201 * @see ModelElementFacade#hasStereotype(String stereotypeName) 1202 */ 1203 public boolean hasStereotype(String stereotypeName) 1204 { 1205 return this.getSuperClassifierFacade().hasStereotype(stereotypeName); 1206 } 1207 1208 /** 1209 * True if there are target dependencies from this element that are instances of BindingFacade. 1210 * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies. 1211 * @see ModelElementFacade#isBindingDependenciesPresent() 1212 */ 1213 public boolean isBindingDependenciesPresent() 1214 { 1215 return this.getSuperClassifierFacade().isBindingDependenciesPresent(); 1216 } 1217 1218 /** 1219 * Indicates if any constraints are present on this model element. 1220 * @see ModelElementFacade#isConstraintsPresent() 1221 */ 1222 public boolean isConstraintsPresent() 1223 { 1224 return this.getSuperClassifierFacade().isConstraintsPresent(); 1225 } 1226 1227 /** 1228 * Indicates if any documentation is present on this model element. 1229 * @see ModelElementFacade#isDocumentationPresent() 1230 */ 1231 public boolean isDocumentationPresent() 1232 { 1233 return this.getSuperClassifierFacade().isDocumentationPresent(); 1234 } 1235 1236 /** 1237 * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript. 1238 * @see ModelElementFacade#isReservedWord() 1239 */ 1240 public boolean isReservedWord() 1241 { 1242 return this.getSuperClassifierFacade().isReservedWord(); 1243 } 1244 1245 /** 1246 * True is there are template parameters on this model element. For UML2, applies to Class, 1247 * Operation, Property, and Parameter. 1248 * @see ModelElementFacade#isTemplateParametersPresent() 1249 */ 1250 public boolean isTemplateParametersPresent() 1251 { 1252 return this.getSuperClassifierFacade().isTemplateParametersPresent(); 1253 } 1254 1255 /** 1256 * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++, 1257 * JavaScript. Contains no spaces, special characters etc. Constraint always applied on 1258 * Enumerations and Interfaces, optionally applies on other model elements. 1259 * @see ModelElementFacade#isValidIdentifierName() 1260 */ 1261 public boolean isValidIdentifierName() 1262 { 1263 return this.getSuperClassifierFacade().isValidIdentifierName(); 1264 } 1265 1266 /** 1267 * Searches for the constraint with the specified 'name' on this model element, and if found 1268 * translates it using the specified 'translation' from a translation library discovered by the 1269 * framework. 1270 * @see ModelElementFacade#translateConstraint(String name, String translation) 1271 */ 1272 public String translateConstraint(String name, String translation) 1273 { 1274 return this.getSuperClassifierFacade().translateConstraint(name, translation); 1275 } 1276 1277 /** 1278 * Translates all constraints belonging to this model element with the given 'translation'. 1279 * @see ModelElementFacade#translateConstraints(String translation) 1280 */ 1281 public String[] translateConstraints(String translation) 1282 { 1283 return this.getSuperClassifierFacade().translateConstraints(translation); 1284 } 1285 1286 /** 1287 * Translates the constraints of the specified 'kind' belonging to this model element. 1288 * @see ModelElementFacade#translateConstraints(String kind, String translation) 1289 */ 1290 public String[] translateConstraints(String kind, String translation) 1291 { 1292 return this.getSuperClassifierFacade().translateConstraints(kind, translation); 1293 } 1294 1295 /** 1296 * @see org.andromda.core.metafacade.MetafacadeBase#initialize() 1297 */ 1298 @Override 1299 public void initialize() 1300 { 1301 this.getSuperClassifierFacade().initialize(); 1302 } 1303 1304 /** 1305 * @return Object getSuperClassifierFacade().getValidationOwner() 1306 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner() 1307 */ 1308 @Override 1309 public Object getValidationOwner() 1310 { 1311 Object owner = this.getSuperClassifierFacade().getValidationOwner(); 1312 return owner; 1313 } 1314 1315 /** 1316 * @return String getSuperClassifierFacade().getValidationName() 1317 * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName() 1318 */ 1319 @Override 1320 public String getValidationName() 1321 { 1322 String name = this.getSuperClassifierFacade().getValidationName(); 1323 return name; 1324 } 1325 1326 /** 1327 * @param validationMessages Collection<ModelValidationMessage> 1328 * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages) 1329 */ 1330 @Override 1331 public void validateInvariants(Collection<ModelValidationMessage> validationMessages) 1332 { 1333 this.getSuperClassifierFacade().validateInvariants(validationMessages); 1334 } 1335 1336 /** 1337 * The property that stores the name of the metafacade. 1338 */ 1339 private static final String NAME_PROPERTY = "name"; 1340 private static final String FQNAME_PROPERTY = "fullyQualifiedName"; 1341 1342 /** 1343 * @see Object#toString() 1344 */ 1345 @Override 1346 public String toString() 1347 { 1348 final StringBuilder toString = new StringBuilder(this.getClass().getName()); 1349 toString.append("["); 1350 try 1351 { 1352 toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY)); 1353 } 1354 catch (final Throwable tryAgain) 1355 { 1356 try 1357 { 1358 toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY)); 1359 } 1360 catch (final Throwable ignore) 1361 { 1362 // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property 1363 } 1364 } 1365 toString.append("]"); 1366 return toString.toString(); 1367 } 1368}