001// license-header java merge-point
002//
003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
004//
005package org.andromda.cartridges.jsf2.metafacades;
006
007import java.util.Collection;
008import org.andromda.core.common.Introspector;
009import org.andromda.core.metafacade.MetafacadeBase;
010import org.andromda.core.metafacade.MetafacadeFactory;
011import org.andromda.core.metafacade.ModelValidationMessage;
012import org.andromda.metafacades.uml.AssociationEndFacade;
013import org.andromda.metafacades.uml.AssociationFacade;
014import org.andromda.metafacades.uml.ClassifierFacade;
015import org.andromda.metafacades.uml.ConstraintFacade;
016import org.andromda.metafacades.uml.DependencyFacade;
017import org.andromda.metafacades.uml.EntityAttribute;
018import org.andromda.metafacades.uml.ManageableEntityAssociationEnd;
019import org.andromda.metafacades.uml.ModelElementFacade;
020import org.andromda.metafacades.uml.ModelFacade;
021import org.andromda.metafacades.uml.PackageFacade;
022import org.andromda.metafacades.uml.StateMachineFacade;
023import org.andromda.metafacades.uml.StereotypeFacade;
024import org.andromda.metafacades.uml.TaggedValueFacade;
025import org.andromda.metafacades.uml.TemplateParameterFacade;
026import org.andromda.metafacades.uml.TypeMappings;
027
028/**
029 * TODO: Model Documentation for
030 * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd
031 * MetafacadeLogic for JSFManageableEntityAssociationEnd
032 *
033 * @see JSFManageableEntityAssociationEnd
034 */
035public abstract class JSFManageableEntityAssociationEndLogic
036    extends MetafacadeBase
037    implements JSFManageableEntityAssociationEnd
038{
039    /**
040     * The underlying UML object
041     * @see Object
042     */
043    protected Object metaObject;
044
045    /** Create Metafacade implementation instance using the MetafacadeFactory from the context
046     * @param metaObjectIn
047     * @param context
048     */
049    protected JSFManageableEntityAssociationEndLogic(Object metaObjectIn, String context)
050    {
051        super(metaObjectIn, getContext(context));
052        this.superManageableEntityAssociationEnd =
053           (ManageableEntityAssociationEnd)
054            MetafacadeFactory.getInstance().createFacadeImpl(
055                    "org.andromda.metafacades.uml.ManageableEntityAssociationEnd",
056                    metaObjectIn,
057                    getContext(context));
058        this.metaObject = metaObjectIn;
059    }
060
061    /**
062     * Gets the context for this metafacade logic instance.
063     * @param context String. Set to JSFManageableEntityAssociationEnd if null
064     * @return context String
065     */
066    private static String getContext(String context)
067    {
068        if (context == null)
069        {
070            context = "org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd";
071        }
072        return context;
073    }
074
075    private ManageableEntityAssociationEnd superManageableEntityAssociationEnd;
076    private boolean superManageableEntityAssociationEndInitialized = false;
077
078    /**
079     * Gets the ManageableEntityAssociationEnd parent instance.
080     * @return this.superManageableEntityAssociationEnd ManageableEntityAssociationEnd
081     */
082    private ManageableEntityAssociationEnd getSuperManageableEntityAssociationEnd()
083    {
084        if (!this.superManageableEntityAssociationEndInitialized)
085        {
086            ((MetafacadeBase)this.superManageableEntityAssociationEnd).setMetafacadeContext(this.getMetafacadeContext());
087            this.superManageableEntityAssociationEndInitialized = true;
088        }
089        return this.superManageableEntityAssociationEnd;
090    }
091
092    /** Reset context only for non-root metafacades
093     * @param context
094     * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
095     */
096    @Override
097    public void resetMetafacadeContext(String context)
098    {
099        if (!this.contextRoot) // reset context only for non-root metafacades
100        {
101            context = getContext(context);  // to have same value as in original constructor call
102            setMetafacadeContext (context);
103            if (this.superManageableEntityAssociationEndInitialized)
104            {
105                ((MetafacadeBase)this.superManageableEntityAssociationEnd).resetMetafacadeContext(context);
106            }
107        }
108    }
109
110    /**
111     * @return boolean true always
112     * @see JSFManageableEntityAssociationEnd
113     */
114    public boolean isJSFManageableEntityAssociationEndMetaType()
115    {
116        return true;
117    }
118
119    // --------------- attributes ---------------------
120
121   /**
122    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getMessageKey()
123    * @return String
124    */
125    protected abstract String handleGetMessageKey();
126
127    private String __messageKey1a;
128    private boolean __messageKey1aSet = false;
129
130    /**
131     * TODO: Model Documentation for
132     * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd.messageKey
133     * @return (String)handleGetMessageKey()
134     */
135    public final String getMessageKey()
136    {
137        String messageKey1a = this.__messageKey1a;
138        if (!this.__messageKey1aSet)
139        {
140            // messageKey has no pre constraints
141            messageKey1a = handleGetMessageKey();
142            // messageKey has no post constraints
143            this.__messageKey1a = messageKey1a;
144            if (isMetafacadePropertyCachingEnabled())
145            {
146                this.__messageKey1aSet = true;
147            }
148        }
149        return messageKey1a;
150    }
151
152   /**
153    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getMessageValue()
154    * @return String
155    */
156    protected abstract String handleGetMessageValue();
157
158    private String __messageValue2a;
159    private boolean __messageValue2aSet = false;
160
161    /**
162     * TODO: Model Documentation for
163     * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd.messageValue
164     * @return (String)handleGetMessageValue()
165     */
166    public final String getMessageValue()
167    {
168        String messageValue2a = this.__messageValue2a;
169        if (!this.__messageValue2aSet)
170        {
171            // messageValue has no pre constraints
172            messageValue2a = handleGetMessageValue();
173            // messageValue has no post constraints
174            this.__messageValue2a = messageValue2a;
175            if (isMetafacadePropertyCachingEnabled())
176            {
177                this.__messageValue2aSet = true;
178            }
179        }
180        return messageValue2a;
181    }
182
183   /**
184    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getOnlineHelpKey()
185    * @return String
186    */
187    protected abstract String handleGetOnlineHelpKey();
188
189    private String __onlineHelpKey3a;
190    private boolean __onlineHelpKey3aSet = false;
191
192    /**
193     * The key to lookup the online help documentation. This documentation is gathered from the
194     * documentation entered by the user, as well as analyzing the model.
195     * @return (String)handleGetOnlineHelpKey()
196     */
197    public final String getOnlineHelpKey()
198    {
199        String onlineHelpKey3a = this.__onlineHelpKey3a;
200        if (!this.__onlineHelpKey3aSet)
201        {
202            // onlineHelpKey has no pre constraints
203            onlineHelpKey3a = handleGetOnlineHelpKey();
204            // onlineHelpKey has no post constraints
205            this.__onlineHelpKey3a = onlineHelpKey3a;
206            if (isMetafacadePropertyCachingEnabled())
207            {
208                this.__onlineHelpKey3aSet = true;
209            }
210        }
211        return onlineHelpKey3a;
212    }
213
214   /**
215    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getOnlineHelpValue()
216    * @return String
217    */
218    protected abstract String handleGetOnlineHelpValue();
219
220    private String __onlineHelpValue4a;
221    private boolean __onlineHelpValue4aSet = false;
222
223    /**
224     * The online help documentation. This documentation is gathered from the documentation entered
225     * by the user, as well as analyzing the model. The format is HTML without any style.
226     * @return (String)handleGetOnlineHelpValue()
227     */
228    public final String getOnlineHelpValue()
229    {
230        String onlineHelpValue4a = this.__onlineHelpValue4a;
231        if (!this.__onlineHelpValue4aSet)
232        {
233            // onlineHelpValue has no pre constraints
234            onlineHelpValue4a = handleGetOnlineHelpValue();
235            // onlineHelpValue has no post constraints
236            this.__onlineHelpValue4a = onlineHelpValue4a;
237            if (isMetafacadePropertyCachingEnabled())
238            {
239                this.__onlineHelpValue4aSet = true;
240            }
241        }
242        return onlineHelpValue4a;
243    }
244
245   /**
246    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getBackingListName()
247    * @return String
248    */
249    protected abstract String handleGetBackingListName();
250
251    private String __backingListName5a;
252    private boolean __backingListName5aSet = false;
253
254    /**
255     * TODO: Model Documentation for
256     * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd.backingListName
257     * @return (String)handleGetBackingListName()
258     */
259    public final String getBackingListName()
260    {
261        String backingListName5a = this.__backingListName5a;
262        if (!this.__backingListName5aSet)
263        {
264            // backingListName has no pre constraints
265            backingListName5a = handleGetBackingListName();
266            // backingListName has no post constraints
267            this.__backingListName5a = backingListName5a;
268            if (isMetafacadePropertyCachingEnabled())
269            {
270                this.__backingListName5aSet = true;
271            }
272        }
273        return backingListName5a;
274    }
275
276   /**
277    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getValueListName()
278    * @return String
279    */
280    protected abstract String handleGetValueListName();
281
282    private String __valueListName6a;
283    private boolean __valueListName6aSet = false;
284
285    /**
286     * TODO: Model Documentation for
287     * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd.valueListName
288     * @return (String)handleGetValueListName()
289     */
290    public final String getValueListName()
291    {
292        String valueListName6a = this.__valueListName6a;
293        if (!this.__valueListName6aSet)
294        {
295            // valueListName has no pre constraints
296            valueListName6a = handleGetValueListName();
297            // valueListName has no post constraints
298            this.__valueListName6a = valueListName6a;
299            if (isMetafacadePropertyCachingEnabled())
300            {
301                this.__valueListName6aSet = true;
302            }
303        }
304        return valueListName6a;
305    }
306
307   /**
308    * @see org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd#getLabelListName()
309    * @return String
310    */
311    protected abstract String handleGetLabelListName();
312
313    private String __labelListName7a;
314    private boolean __labelListName7aSet = false;
315
316    /**
317     * TODO: Model Documentation for
318     * org.andromda.cartridges.jsf2.metafacades.JSFManageableEntityAssociationEnd.labelListName
319     * @return (String)handleGetLabelListName()
320     */
321    public final String getLabelListName()
322    {
323        String labelListName7a = this.__labelListName7a;
324        if (!this.__labelListName7aSet)
325        {
326            // labelListName has no pre constraints
327            labelListName7a = handleGetLabelListName();
328            // labelListName has no post constraints
329            this.__labelListName7a = labelListName7a;
330            if (isMetafacadePropertyCachingEnabled())
331            {
332                this.__labelListName7aSet = true;
333            }
334        }
335        return labelListName7a;
336    }
337
338    /**
339     * @return true
340     * @see ManageableEntityAssociationEnd
341     */
342    public boolean isManageableEntityAssociationEndMetaType()
343    {
344        return true;
345    }
346
347    /**
348     * @return true
349     * @see org.andromda.metafacades.uml.EntityAssociationEnd
350     */
351    public boolean isEntityAssociationEndMetaType()
352    {
353        return true;
354    }
355
356    /**
357     * @return true
358     * @see AssociationEndFacade
359     */
360    public boolean isAssociationEndFacadeMetaType()
361    {
362        return true;
363    }
364
365    /**
366     * @return true
367     * @see ModelElementFacade
368     */
369    public boolean isModelElementFacadeMetaType()
370    {
371        return true;
372    }
373
374    // ----------- delegates to ManageableEntityAssociationEnd ------------
375    /**
376     * A name suitable for use when adding new elements to this association end in programming code.
377     * @see AssociationEndFacade#getAdderName()
378     */
379    public String getAdderName()
380    {
381        return this.getSuperManageableEntityAssociationEnd().getAdderName();
382    }
383
384    /**
385     * Returns the value of the 'Aggregation' attribute (none, shared, composite). The default value
386     * is "none". The literals are from the enumeration org.eclipse.uml2.uml.AggregationKind.
387     * Specifies the kind of aggregation that applies to the Property.
388     * @see AssociationEndFacade#getAggregationKind()
389     */
390    public String getAggregationKind()
391    {
392        return this.getSuperManageableEntityAssociationEnd().getAggregationKind();
393    }
394
395    /**
396     * The association owning this association end.
397     * @see AssociationEndFacade#getAssociation()
398     */
399    public AssociationFacade getAssociation()
400    {
401        return this.getSuperManageableEntityAssociationEnd().getAssociation();
402    }
403
404    /**
405     * UML2: Returns the value of the 'Default' attribute. Specifies a String that represents a
406     * value to be used when no argument is supplied for the Property. A String that is evaluated to
407     * give a default value for the Property when an object of the owning Classifier is
408     * instantiated.  Can be something like: new ValueObject(values);
409     * @see AssociationEndFacade#getDefault()
410     */
411    public String getDefault()
412    {
413        return this.getSuperManageableEntityAssociationEnd().getDefault();
414    }
415
416    /**
417     * A name suitable for use when accessing this association end in programming code.
418     * @see AssociationEndFacade#getGetterName()
419     */
420    public String getGetterName()
421    {
422        return this.getSuperManageableEntityAssociationEnd().getGetterName();
423    }
424
425    /**
426     * The name of the type that is returned on the accessor and mutator operations,  determined in
427     * part by the multiplicity.
428     * @see AssociationEndFacade#getGetterSetterTypeName()
429     */
430    public String getGetterSetterTypeName()
431    {
432        return this.getSuperManageableEntityAssociationEnd().getGetterSetterTypeName();
433    }
434
435    /**
436     * the lower value for the multiplicity
437     * -only applicable for UML2
438     * @see AssociationEndFacade#getLower()
439     */
440    public int getLower()
441    {
442        return this.getSuperManageableEntityAssociationEnd().getLower();
443    }
444
445    /**
446     * The other association end owned by this end's association.
447     * @see AssociationEndFacade#getOtherEnd()
448     */
449    public AssociationEndFacade getOtherEnd()
450    {
451        return this.getSuperManageableEntityAssociationEnd().getOtherEnd();
452    }
453
454    /**
455     * A name suitable for use when removing element from this association end in programming code.
456     * @see AssociationEndFacade#getRemoverName()
457     */
458    public String getRemoverName()
459    {
460        return this.getSuperManageableEntityAssociationEnd().getRemoverName();
461    }
462
463    /**
464     * A name suitable for use when accessing this association end in programming code.
465     * @see AssociationEndFacade#getSetterName()
466     */
467    public String getSetterName()
468    {
469        return this.getSuperManageableEntityAssociationEnd().getSetterName();
470    }
471
472    /**
473     * The classifier attached to this association end.
474     * @see AssociationEndFacade#getType()
475     */
476    public ClassifierFacade getType()
477    {
478        return this.getSuperManageableEntityAssociationEnd().getType();
479    }
480
481    /**
482     * the upper value for the multiplicity (will be -1 for *)
483     * -only applicable for UML2
484     * @see AssociationEndFacade#getUpper()
485     */
486    public int getUpper()
487    {
488        return this.getSuperManageableEntityAssociationEnd().getUpper();
489    }
490
491    /**
492     * True if this association end represents an aggregation relationship.
493     * @see AssociationEndFacade#isAggregation()
494     */
495    public boolean isAggregation()
496    {
497        return this.getSuperManageableEntityAssociationEnd().isAggregation();
498    }
499
500    /**
501     * Is true if update of one side of the association should also update the other side. false if
502     * not.
503     * @see AssociationEndFacade#isBidirectional()
504     */
505    public boolean isBidirectional()
506    {
507        return this.getSuperManageableEntityAssociationEnd().isBidirectional();
508    }
509
510    /**
511     * Returns whether or not (true/false) this association end is the child end of the assocation
512     * (i.e. the other end's aggregation is composition).
513     * @see AssociationEndFacade#isChild()
514     */
515    public boolean isChild()
516    {
517        return this.getSuperManageableEntityAssociationEnd().isChild();
518    }
519
520    /**
521     * True if this association end represents a composition relationship.
522     * @see AssociationEndFacade#isComposition()
523     */
524    public boolean isComposition()
525    {
526        return this.getSuperManageableEntityAssociationEnd().isComposition();
527    }
528
529    /**
530     * If the association end is derived (its value is computed). UML2 only. UML14 always returns
531     * false. Default=false.
532     * @see AssociationEndFacade#isDerived()
533     */
534    public boolean isDerived()
535    {
536        return this.getSuperManageableEntityAssociationEnd().isDerived();
537    }
538
539    /**
540     * IsLeaf property in the association end property. If true, attribute is final, cannot be
541     * extended or implemented by a descendant. Default=false.
542     * @see AssociationEndFacade#isLeaf()
543     */
544    public boolean isLeaf()
545    {
546        return this.getSuperManageableEntityAssociationEnd().isLeaf();
547    }
548
549    /**
550     * True if this association end's multiplicity is greater than one.
551     * @see AssociationEndFacade#isMany()
552     */
553    public boolean isMany()
554    {
555        return this.getSuperManageableEntityAssociationEnd().isMany();
556    }
557
558    /**
559     * True if this association end's and the other end's multiplicities are both many.
560     * @see AssociationEndFacade#isMany2Many()
561     */
562    public boolean isMany2Many()
563    {
564        return this.getSuperManageableEntityAssociationEnd().isMany2Many();
565    }
566
567    /**
568     * True if this association end's multiplicity is many while the other end's is one.
569     * @see AssociationEndFacade#isMany2One()
570     */
571    public boolean isMany2One()
572    {
573        return this.getSuperManageableEntityAssociationEnd().isMany2One();
574    }
575
576    /**
577     * True if it is possible to navigate from the other end to this association end .
578     * @see AssociationEndFacade#isNavigable()
579     */
580    public boolean isNavigable()
581    {
582        return this.getSuperManageableEntityAssociationEnd().isNavigable();
583    }
584
585    /**
586     * True if this association end's multiplicity is one while the other end's is many.
587     * @see AssociationEndFacade#isOne2Many()
588     */
589    public boolean isOne2Many()
590    {
591        return this.getSuperManageableEntityAssociationEnd().isOne2Many();
592    }
593
594    /**
595     * True if this association end's and the other end's multiplicities are both one.
596     * @see AssociationEndFacade#isOne2One()
597     */
598    public boolean isOne2One()
599    {
600        return this.getSuperManageableEntityAssociationEnd().isOne2One();
601    }
602
603    /**
604     * Indicates whether or not the association ends are ordered (if multiplicity is greater than
605     * 1).
606     * @see AssociationEndFacade#isOrdered()
607     */
608    public boolean isOrdered()
609    {
610        return this.getSuperManageableEntityAssociationEnd().isOrdered();
611    }
612
613    /**
614     * True if the association end cannot be changed.
615     * @see AssociationEndFacade#isReadOnly()
616     */
617    public boolean isReadOnly()
618    {
619        return this.getSuperManageableEntityAssociationEnd().isReadOnly();
620    }
621
622    /**
623     * True if this association end's multiplicity is strictly greater than zero.
624     * @see AssociationEndFacade#isRequired()
625     */
626    public boolean isRequired()
627    {
628        return this.getSuperManageableEntityAssociationEnd().isRequired();
629    }
630
631    /**
632     * Indicates if this associationEnd is 'static', meaning it has a classifier scope.
633     * @see AssociationEndFacade#isStatic()
634     */
635    public boolean isStatic()
636    {
637        return this.getSuperManageableEntityAssociationEnd().isStatic();
638    }
639
640    /**
641     * UML2: If the association attribute is unique within the Collection type. UML14 always returns
642     * false. Unique+Ordered determines the implementation Collection type. Default=false.
643     * @see AssociationEndFacade#isUnique()
644     */
645    public boolean isUnique()
646    {
647        return this.getSuperManageableEntityAssociationEnd().isUnique();
648    }
649
650    /**
651     * The name of the index to create on a column that persists the foreign key attribute.
652     * @see org.andromda.metafacades.uml.EntityAssociationEnd#getColumnIndex()
653     */
654    public String getColumnIndex()
655    {
656        return this.getSuperManageableEntityAssociationEnd().getColumnIndex();
657    }
658
659    /**
660     * The name of the column that makes up the foreign key.
661     * @see org.andromda.metafacades.uml.EntityAssociationEnd#getColumnName()
662     */
663    public String getColumnName()
664    {
665        return this.getSuperManageableEntityAssociationEnd().getColumnName();
666    }
667
668    /**
669     * The name of the foreign key constraint to use for databases.
670     * @see org.andromda.metafacades.uml.EntityAssociationEnd#getForeignKeyConstraintName()
671     */
672    public String getForeignKeyConstraintName()
673    {
674        return this.getSuperManageableEntityAssociationEnd().getForeignKeyConstraintName();
675    }
676
677    /**
678     * The current foreign key suffix specified for this entity association end facade.
679     * @see org.andromda.metafacades.uml.EntityAssociationEnd#getForeignKeySuffix()
680     */
681    public String getForeignKeySuffix()
682    {
683        return this.getSuperManageableEntityAssociationEnd().getForeignKeySuffix();
684    }
685
686    /**
687     * The SQL type for this the foreign key column of this association end.
688     * @see org.andromda.metafacades.uml.EntityAssociationEnd#getSqlType()
689     */
690    public String getSqlType()
691    {
692        return this.getSuperManageableEntityAssociationEnd().getSqlType();
693    }
694
695    /**
696     * The name of the unique-key that this unique association end belongs
697     * @see org.andromda.metafacades.uml.EntityAssociationEnd#getUniqueGroup()
698     */
699    public String getUniqueGroup()
700    {
701        return this.getSuperManageableEntityAssociationEnd().getUniqueGroup();
702    }
703
704    /**
705     * Indicates whether or not a foreign identifier should be used for the entity that owns this
706     * association end.  This would only make sense in the case of a child in a one-to-one
707     * parent-child association.  If this flag is true, then the identifier of this entity should
708     * also be used as the foreign key to the related parent entity.
709     * @see org.andromda.metafacades.uml.EntityAssociationEnd#isForeignIdentifier()
710     */
711    public boolean isForeignIdentifier()
712    {
713        return this.getSuperManageableEntityAssociationEnd().isForeignIdentifier();
714    }
715
716    /**
717     * True if this association is an identifier for its entity.
718     * @see org.andromda.metafacades.uml.EntityAssociationEnd#isIdentifier()
719     */
720    public boolean isIdentifier()
721    {
722        return this.getSuperManageableEntityAssociationEnd().isIdentifier();
723    }
724
725    /**
726     * True if the associationEnd is marked with identifiers stereotype, false otherwise.
727     * @see org.andromda.metafacades.uml.EntityAssociationEnd#isIdentifiersPresent()
728     */
729    public boolean isIdentifiersPresent()
730    {
731        return this.getSuperManageableEntityAssociationEnd().isIdentifiersPresent();
732    }
733
734    /**
735     * Indicates this association end should be ignored by the persistence layer.
736     * @see org.andromda.metafacades.uml.EntityAssociationEnd#isTransient()
737     */
738    public boolean isTransient()
739    {
740        return this.getSuperManageableEntityAssociationEnd().isTransient();
741    }
742
743    /**
744     * Represents an attribute of an entity.
745     * @see ManageableEntityAssociationEnd#getManageableIdentifier()
746     */
747    public EntityAttribute getManageableIdentifier()
748    {
749        return this.getSuperManageableEntityAssociationEnd().getManageableIdentifier();
750    }
751
752    /**
753     * Whether or not this association end should be displayed.
754     * @see ManageableEntityAssociationEnd#isDisplay()
755     */
756    public boolean isDisplay()
757    {
758        return this.getSuperManageableEntityAssociationEnd().isDisplay();
759    }
760
761    /**
762     * Copies all tagged values from the given ModelElementFacade to this model element facade.
763     * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
764     */
765    public void copyTaggedValues(ModelElementFacade element)
766    {
767        this.getSuperManageableEntityAssociationEnd().copyTaggedValues(element);
768    }
769
770    /**
771     * Finds the tagged value with the specified 'tagName'. In case there are more values the first
772     * one found will be returned.
773     * @see ModelElementFacade#findTaggedValue(String tagName)
774     */
775    public Object findTaggedValue(String tagName)
776    {
777        return this.getSuperManageableEntityAssociationEnd().findTaggedValue(tagName);
778    }
779
780    /**
781     * Returns all the values for the tagged value with the specified name. The returned collection
782     * will contains only String instances, or will be empty. Never null.
783     * @see ModelElementFacade#findTaggedValues(String tagName)
784     */
785    public Collection<Object> findTaggedValues(String tagName)
786    {
787        return this.getSuperManageableEntityAssociationEnd().findTaggedValues(tagName);
788    }
789
790    /**
791     * Returns the fully qualified name of the model element. The fully qualified name includes
792     * complete package qualified name of the underlying model element. The templates parameter will
793     * be replaced by the correct one given the binding relation of the parameter to this element.
794     * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
795     */
796    public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
797    {
798        return this.getSuperManageableEntityAssociationEnd().getBindedFullyQualifiedName(bindedElement);
799    }
800
801    /**
802     * Gets all constraints belonging to the model element.
803     * @see ModelElementFacade#getConstraints()
804     */
805    public Collection<ConstraintFacade> getConstraints()
806    {
807        return this.getSuperManageableEntityAssociationEnd().getConstraints();
808    }
809
810    /**
811     * Returns the constraints of the argument kind that have been placed onto this model. Typical
812     * kinds are "inv", "pre" and "post". Other kinds are possible.
813     * @see ModelElementFacade#getConstraints(String kind)
814     */
815    public Collection<ConstraintFacade> getConstraints(String kind)
816    {
817        return this.getSuperManageableEntityAssociationEnd().getConstraints(kind);
818    }
819
820    /**
821     * Gets the documentation for the model element, The indent argument is prefixed to each line.
822     * By default this method wraps lines after 64 characters.
823     * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
824     * @see ModelElementFacade#getDocumentation(String indent)
825     */
826    public String getDocumentation(String indent)
827    {
828        return this.getSuperManageableEntityAssociationEnd().getDocumentation(indent);
829    }
830
831    /**
832     * This method returns the documentation for this model element, with the lines wrapped after
833     * the specified number of characters, values of less than 1 will indicate no line wrapping is
834     * required. By default paragraphs are returned as HTML.
835     * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
836     * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
837     */
838    public String getDocumentation(String indent, int lineLength)
839    {
840        return this.getSuperManageableEntityAssociationEnd().getDocumentation(indent, lineLength);
841    }
842
843    /**
844     * This method returns the documentation for this model element, with the lines wrapped after
845     * the specified number of characters, values of less than 1 will indicate no line wrapping is
846     * required. HTML style determines if HTML Escaping is applied.
847     * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
848     */
849    public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
850    {
851        return this.getSuperManageableEntityAssociationEnd().getDocumentation(indent, lineLength, htmlStyle);
852    }
853
854    /**
855     * The fully qualified name of this model element.
856     * @see ModelElementFacade#getFullyQualifiedName()
857     */
858    public String getFullyQualifiedName()
859    {
860        return this.getSuperManageableEntityAssociationEnd().getFullyQualifiedName();
861    }
862
863    /**
864     * Returns the fully qualified name of the model element. The fully qualified name includes
865     * complete package qualified name of the underlying model element.  If modelName is true, then
866     * the original name of the model element (the name contained within the model) will be the name
867     * returned, otherwise a name from a language mapping will be returned.
868     * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
869     */
870    public String getFullyQualifiedName(boolean modelName)
871    {
872        return this.getSuperManageableEntityAssociationEnd().getFullyQualifiedName(modelName);
873    }
874
875    /**
876     * Returns the fully qualified name as a path, the returned value always starts with out a slash
877     * '/'.
878     * @see ModelElementFacade#getFullyQualifiedNamePath()
879     */
880    public String getFullyQualifiedNamePath()
881    {
882        return this.getSuperManageableEntityAssociationEnd().getFullyQualifiedNamePath();
883    }
884
885    /**
886     * Gets the unique identifier of the underlying model element.
887     * @see ModelElementFacade#getId()
888     */
889    public String getId()
890    {
891        return this.getSuperManageableEntityAssociationEnd().getId();
892    }
893
894    /**
895     * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
896     * are not represented by other properties, i.e. native, transient, volatile, synchronized,
897     * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
898     * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
899     * JDK5 compiler level.
900     * @see ModelElementFacade#getKeywords()
901     */
902    public Collection<String> getKeywords()
903    {
904        return this.getSuperManageableEntityAssociationEnd().getKeywords();
905    }
906
907    /**
908     * UML2: Retrieves a localized label for this named element.
909     * @see ModelElementFacade#getLabel()
910     */
911    public String getLabel()
912    {
913        return this.getSuperManageableEntityAssociationEnd().getLabel();
914    }
915
916    /**
917     * The language mappings that have been set for this model element.
918     * @see ModelElementFacade#getLanguageMappings()
919     */
920    public TypeMappings getLanguageMappings()
921    {
922        return this.getSuperManageableEntityAssociationEnd().getLanguageMappings();
923    }
924
925    /**
926     * Return the model containing this model element (multiple models may be loaded and processed
927     * at the same time).
928     * @see ModelElementFacade#getModel()
929     */
930    public ModelFacade getModel()
931    {
932        return this.getSuperManageableEntityAssociationEnd().getModel();
933    }
934
935    /**
936     * The name of the model element.
937     * @see ModelElementFacade#getName()
938     */
939    public String getName()
940    {
941        return this.getSuperManageableEntityAssociationEnd().getName();
942    }
943
944    /**
945     * Gets the package to which this model element belongs.
946     * @see ModelElementFacade#getPackage()
947     */
948    public ModelElementFacade getPackage()
949    {
950        return this.getSuperManageableEntityAssociationEnd().getPackage();
951    }
952
953    /**
954     * The name of this model element's package.
955     * @see ModelElementFacade#getPackageName()
956     */
957    public String getPackageName()
958    {
959        return this.getSuperManageableEntityAssociationEnd().getPackageName();
960    }
961
962    /**
963     * Gets the package name (optionally providing the ability to retrieve the model name and not
964     * the mapped name).
965     * @see ModelElementFacade#getPackageName(boolean modelName)
966     */
967    public String getPackageName(boolean modelName)
968    {
969        return this.getSuperManageableEntityAssociationEnd().getPackageName(modelName);
970    }
971
972    /**
973     * Returns the package as a path, the returned value always starts with out a slash '/'.
974     * @see ModelElementFacade#getPackagePath()
975     */
976    public String getPackagePath()
977    {
978        return this.getSuperManageableEntityAssociationEnd().getPackagePath();
979    }
980
981    /**
982     * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
983     * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
984     * the names of the containing namespaces starting at the root of the hierarchy and ending with
985     * the name of the NamedElement itself.
986     * @see ModelElementFacade#getQualifiedName()
987     */
988    public String getQualifiedName()
989    {
990        return this.getSuperManageableEntityAssociationEnd().getQualifiedName();
991    }
992
993    /**
994     * Gets the root package for the model element.
995     * @see ModelElementFacade#getRootPackage()
996     */
997    public PackageFacade getRootPackage()
998    {
999        return this.getSuperManageableEntityAssociationEnd().getRootPackage();
1000    }
1001
1002    /**
1003     * Gets the dependencies for which this model element is the source.
1004     * @see ModelElementFacade#getSourceDependencies()
1005     */
1006    public Collection<DependencyFacade> getSourceDependencies()
1007    {
1008        return this.getSuperManageableEntityAssociationEnd().getSourceDependencies();
1009    }
1010
1011    /**
1012     * If this model element is the context of an activity graph, this represents that activity
1013     * graph.
1014     * @see ModelElementFacade#getStateMachineContext()
1015     */
1016    public StateMachineFacade getStateMachineContext()
1017    {
1018        return this.getSuperManageableEntityAssociationEnd().getStateMachineContext();
1019    }
1020
1021    /**
1022     * The collection of ALL stereotype names for this model element.
1023     * @see ModelElementFacade#getStereotypeNames()
1024     */
1025    public Collection<String> getStereotypeNames()
1026    {
1027        return this.getSuperManageableEntityAssociationEnd().getStereotypeNames();
1028    }
1029
1030    /**
1031     * Gets all stereotypes for this model element.
1032     * @see ModelElementFacade#getStereotypes()
1033     */
1034    public Collection<StereotypeFacade> getStereotypes()
1035    {
1036        return this.getSuperManageableEntityAssociationEnd().getStereotypes();
1037    }
1038
1039    /**
1040     * Return the TaggedValues associated with this model element, under all stereotypes.
1041     * @see ModelElementFacade#getTaggedValues()
1042     */
1043    public Collection<TaggedValueFacade> getTaggedValues()
1044    {
1045        return this.getSuperManageableEntityAssociationEnd().getTaggedValues();
1046    }
1047
1048    /**
1049     * Gets the dependencies for which this model element is the target.
1050     * @see ModelElementFacade#getTargetDependencies()
1051     */
1052    public Collection<DependencyFacade> getTargetDependencies()
1053    {
1054        return this.getSuperManageableEntityAssociationEnd().getTargetDependencies();
1055    }
1056
1057    /**
1058     * Get the template parameter for this model element having the parameterName
1059     * @see ModelElementFacade#getTemplateParameter(String parameterName)
1060     */
1061    public Object getTemplateParameter(String parameterName)
1062    {
1063        return this.getSuperManageableEntityAssociationEnd().getTemplateParameter(parameterName);
1064    }
1065
1066    /**
1067     * Get the template parameters for this model element
1068     * @see ModelElementFacade#getTemplateParameters()
1069     */
1070    public Collection<TemplateParameterFacade> getTemplateParameters()
1071    {
1072        return this.getSuperManageableEntityAssociationEnd().getTemplateParameters();
1073    }
1074
1075    /**
1076     * The visibility (i.e. public, private, protected or package) of the model element, will
1077     * attempt a lookup for these values in the language mappings (if any).
1078     * @see ModelElementFacade#getVisibility()
1079     */
1080    public String getVisibility()
1081    {
1082        return this.getSuperManageableEntityAssociationEnd().getVisibility();
1083    }
1084
1085    /**
1086     * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
1087     * is taken into account when searching for the stereotype), false otherwise.
1088     * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
1089     */
1090    public boolean hasExactStereotype(String stereotypeName)
1091    {
1092        return this.getSuperManageableEntityAssociationEnd().hasExactStereotype(stereotypeName);
1093    }
1094
1095    /**
1096     * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
1097     * pipe, semicolon, or << >>
1098     * @see ModelElementFacade#hasKeyword(String keywordName)
1099     */
1100    public boolean hasKeyword(String keywordName)
1101    {
1102        return this.getSuperManageableEntityAssociationEnd().hasKeyword(keywordName);
1103    }
1104
1105    /**
1106     * Returns true if the model element has the specified stereotype.  If the stereotype itself
1107     * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
1108     * one of the stereotype's ancestors has a matching name this method will return true, false
1109     * otherwise.
1110     * For example, if we have a certain stereotype called <<exception>> and a model element has a
1111     * stereotype called <<applicationException>> which extends <<exception>>, when calling this
1112     * method with 'stereotypeName' defined as 'exception' the method would return true since
1113     * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
1114     * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
1115     * @see ModelElementFacade#hasStereotype(String stereotypeName)
1116     */
1117    public boolean hasStereotype(String stereotypeName)
1118    {
1119        return this.getSuperManageableEntityAssociationEnd().hasStereotype(stereotypeName);
1120    }
1121
1122    /**
1123     * True if there are target dependencies from this element that are instances of BindingFacade.
1124     * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
1125     * @see ModelElementFacade#isBindingDependenciesPresent()
1126     */
1127    public boolean isBindingDependenciesPresent()
1128    {
1129        return this.getSuperManageableEntityAssociationEnd().isBindingDependenciesPresent();
1130    }
1131
1132    /**
1133     * Indicates if any constraints are present on this model element.
1134     * @see ModelElementFacade#isConstraintsPresent()
1135     */
1136    public boolean isConstraintsPresent()
1137    {
1138        return this.getSuperManageableEntityAssociationEnd().isConstraintsPresent();
1139    }
1140
1141    /**
1142     * Indicates if any documentation is present on this model element.
1143     * @see ModelElementFacade#isDocumentationPresent()
1144     */
1145    public boolean isDocumentationPresent()
1146    {
1147        return this.getSuperManageableEntityAssociationEnd().isDocumentationPresent();
1148    }
1149
1150    /**
1151     * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
1152     * @see ModelElementFacade#isReservedWord()
1153     */
1154    public boolean isReservedWord()
1155    {
1156        return this.getSuperManageableEntityAssociationEnd().isReservedWord();
1157    }
1158
1159    /**
1160     * True is there are template parameters on this model element. For UML2, applies to Class,
1161     * Operation, Property, and Parameter.
1162     * @see ModelElementFacade#isTemplateParametersPresent()
1163     */
1164    public boolean isTemplateParametersPresent()
1165    {
1166        return this.getSuperManageableEntityAssociationEnd().isTemplateParametersPresent();
1167    }
1168
1169    /**
1170     * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
1171     * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
1172     * Enumerations and Interfaces, optionally applies on other model elements.
1173     * @see ModelElementFacade#isValidIdentifierName()
1174     */
1175    public boolean isValidIdentifierName()
1176    {
1177        return this.getSuperManageableEntityAssociationEnd().isValidIdentifierName();
1178    }
1179
1180    /**
1181     * Searches for the constraint with the specified 'name' on this model element, and if found
1182     * translates it using the specified 'translation' from a translation library discovered by the
1183     * framework.
1184     * @see ModelElementFacade#translateConstraint(String name, String translation)
1185     */
1186    public String translateConstraint(String name, String translation)
1187    {
1188        return this.getSuperManageableEntityAssociationEnd().translateConstraint(name, translation);
1189    }
1190
1191    /**
1192     * Translates all constraints belonging to this model element with the given 'translation'.
1193     * @see ModelElementFacade#translateConstraints(String translation)
1194     */
1195    public String[] translateConstraints(String translation)
1196    {
1197        return this.getSuperManageableEntityAssociationEnd().translateConstraints(translation);
1198    }
1199
1200    /**
1201     * Translates the constraints of the specified 'kind' belonging to this model element.
1202     * @see ModelElementFacade#translateConstraints(String kind, String translation)
1203     */
1204    public String[] translateConstraints(String kind, String translation)
1205    {
1206        return this.getSuperManageableEntityAssociationEnd().translateConstraints(kind, translation);
1207    }
1208
1209    /**
1210     * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
1211     */
1212    @Override
1213    public void initialize()
1214    {
1215        this.getSuperManageableEntityAssociationEnd().initialize();
1216    }
1217
1218    /**
1219     * @return Object getSuperManageableEntityAssociationEnd().getValidationOwner()
1220     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
1221     */
1222    @Override
1223    public Object getValidationOwner()
1224    {
1225        Object owner = this.getSuperManageableEntityAssociationEnd().getValidationOwner();
1226        return owner;
1227    }
1228
1229    /**
1230     * @return String getSuperManageableEntityAssociationEnd().getValidationName()
1231     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1232     */
1233    @Override
1234    public String getValidationName()
1235    {
1236        String name = this.getSuperManageableEntityAssociationEnd().getValidationName();
1237        return name;
1238    }
1239
1240    /**
1241     * @param validationMessages Collection<ModelValidationMessage>
1242     * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1243     */
1244    @Override
1245    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1246    {
1247        this.getSuperManageableEntityAssociationEnd().validateInvariants(validationMessages);
1248    }
1249
1250    /**
1251     * The property that stores the name of the metafacade.
1252     */
1253    private static final String NAME_PROPERTY = "name";
1254    private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1255
1256    /**
1257     * @see Object#toString()
1258     */
1259    @Override
1260    public String toString()
1261    {
1262        final StringBuilder toString = new StringBuilder(this.getClass().getName());
1263        toString.append("[");
1264        try
1265        {
1266            toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1267        }
1268        catch (final Throwable tryAgain)
1269        {
1270            try
1271            {
1272                toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1273            }
1274            catch (final Throwable ignore)
1275            {
1276                // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1277            }
1278        }
1279        toString.append("]");
1280        return toString.toString();
1281    }
1282}