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