Source code

001// license-header java merge-point
002//
003// Attention: generated code (by MetafacadeLogic.vsl) - do not modify!
004//
005package org.andromda.cartridges.ejb3.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.ConstraintFacade;
013import org.andromda.metafacades.uml.DependencyFacade;
014import org.andromda.metafacades.uml.ModelElementFacade;
015import org.andromda.metafacades.uml.ModelFacade;
016import org.andromda.metafacades.uml.PackageFacade;
017import org.andromda.metafacades.uml.StateMachineFacade;
018import org.andromda.metafacades.uml.StereotypeFacade;
019import org.andromda.metafacades.uml.TaggedValueFacade;
020import org.andromda.metafacades.uml.TemplateParameterFacade;
021import org.andromda.metafacades.uml.TypeMappings;
022
023/**
024 * TODO: Model Documentation for org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade
025 * MetafacadeLogic for EJB3DependencyFacade
026 *
027 * @see EJB3DependencyFacade
028 */
029public abstract class EJB3DependencyFacadeLogic
030    extends MetafacadeBase
031    implements EJB3DependencyFacade
032{
033    /**
034     * The underlying UML object
035     * @see Object
036     */
037    protected Object metaObject;
038
039    /** Create Metafacade implementation instance using the MetafacadeFactory from the context
040     * @param metaObjectIn
041     * @param context
042     */
043    protected EJB3DependencyFacadeLogic(Object metaObjectIn, String context)
044    {
045        super(metaObjectIn, getContext(context));
046        this.superDependencyFacade =
047           (DependencyFacade)
048            MetafacadeFactory.getInstance().createFacadeImpl(
049                    "org.andromda.metafacades.uml.DependencyFacade",
050                    metaObjectIn,
051                    getContext(context));
052        this.metaObject = metaObjectIn;
053    }
054
055    /**
056     * Gets the context for this metafacade logic instance.
057     * @param context String. Set to EJB3DependencyFacade if null
058     * @return context String
059     */
060    private static String getContext(String context)
061    {
062        if (context == null)
063        {
064            context = "org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade";
065        }
066        return context;
067    }
068
069    private DependencyFacade superDependencyFacade;
070    private boolean superDependencyFacadeInitialized = false;
071
072    /**
073     * Gets the DependencyFacade parent instance.
074     * @return this.superDependencyFacade DependencyFacade
075     */
076    private DependencyFacade getSuperDependencyFacade()
077    {
078        if (!this.superDependencyFacadeInitialized)
079        {
080            ((MetafacadeBase)this.superDependencyFacade).setMetafacadeContext(this.getMetafacadeContext());
081            this.superDependencyFacadeInitialized = true;
082        }
083        return this.superDependencyFacade;
084    }
085
086    /** Reset context only for non-root metafacades
087     * @param context
088     * @see org.andromda.core.metafacade.MetafacadeBase#resetMetafacadeContext(String context)
089     */
090    @Override
091    public void resetMetafacadeContext(String context)
092    {
093        if (!this.contextRoot) // reset context only for non-root metafacades
094        {
095            context = getContext(context);  // to have same value as in original constructor call
096            setMetafacadeContext (context);
097            if (this.superDependencyFacadeInitialized)
098            {
099                ((MetafacadeBase)this.superDependencyFacade).resetMetafacadeContext(context);
100            }
101        }
102    }
103
104    /**
105     * @return boolean true always
106     * @see EJB3DependencyFacade
107     */
108    public boolean isEJB3DependencyFacadeMetaType()
109    {
110        return true;
111    }
112
113    // --------------- attributes ---------------------
114
115   /**
116    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationConstantName()
117    * @return String
118    */
119    protected abstract String handleGetTransformationConstantName();
120
121    private String __transformationConstantName1a;
122    private boolean __transformationConstantName1aSet = false;
123
124    /**
125     * The name of the constant designated for use as a transformation flag for value objects (only
126     * makes sense when this dependency goes into a value object).
127     * @return (String)handleGetTransformationConstantName()
128     */
129    public final String getTransformationConstantName()
130    {
131        String transformationConstantName1a = this.__transformationConstantName1a;
132        if (!this.__transformationConstantName1aSet)
133        {
134            // transformationConstantName has no pre constraints
135            transformationConstantName1a = handleGetTransformationConstantName();
136            // transformationConstantName has no post constraints
137            this.__transformationConstantName1a = transformationConstantName1a;
138            if (isMetafacadePropertyCachingEnabled())
139            {
140                this.__transformationConstantName1aSet = true;
141            }
142        }
143        return transformationConstantName1a;
144    }
145
146   /**
147    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationMethodName()
148    * @return String
149    */
150    protected abstract String handleGetTransformationMethodName();
151
152    private String __transformationMethodName2a;
153    private boolean __transformationMethodName2aSet = false;
154
155    /**
156     * The name of the method used for transformation into a value object (only makes sense when
157     * this dependency goes into a value object).
158     * @return (String)handleGetTransformationMethodName()
159     */
160    public final String getTransformationMethodName()
161    {
162        String transformationMethodName2a = this.__transformationMethodName2a;
163        if (!this.__transformationMethodName2aSet)
164        {
165            // transformationMethodName has no pre constraints
166            transformationMethodName2a = handleGetTransformationMethodName();
167            // transformationMethodName has no post constraints
168            this.__transformationMethodName2a = transformationMethodName2a;
169            if (isMetafacadePropertyCachingEnabled())
170            {
171                this.__transformationMethodName2aSet = true;
172            }
173        }
174        return transformationMethodName2a;
175    }
176
177   /**
178    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationAnonymousName()
179    * @return String
180    */
181    protected abstract String handleGetTransformationAnonymousName();
182
183    private String __transformationAnonymousName3a;
184    private boolean __transformationAnonymousName3aSet = false;
185
186    /**
187     * TODO: Model Documentation for
188     * org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade.transformationAnonymousName
189     * @return (String)handleGetTransformationAnonymousName()
190     */
191    public final String getTransformationAnonymousName()
192    {
193        String transformationAnonymousName3a = this.__transformationAnonymousName3a;
194        if (!this.__transformationAnonymousName3aSet)
195        {
196            // transformationAnonymousName has no pre constraints
197            transformationAnonymousName3a = handleGetTransformationAnonymousName();
198            // transformationAnonymousName has no post constraints
199            this.__transformationAnonymousName3a = transformationAnonymousName3a;
200            if (isMetafacadePropertyCachingEnabled())
201            {
202                this.__transformationAnonymousName3aSet = true;
203            }
204        }
205        return transformationAnonymousName3a;
206    }
207
208   /**
209    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#isCircularReference()
210    * @return boolean
211    */
212    protected abstract boolean handleIsCircularReference();
213
214    private boolean __circularReference4a;
215    private boolean __circularReference4aSet = false;
216
217    /**
218     * Indicates if this dependency is part of a circular reference (meaning that both entities
219     * reference each other).
220     * @return (boolean)handleIsCircularReference()
221     */
222    public final boolean isCircularReference()
223    {
224        boolean circularReference4a = this.__circularReference4a;
225        if (!this.__circularReference4aSet)
226        {
227            // circularReference has no pre constraints
228            circularReference4a = handleIsCircularReference();
229            // circularReference has no post constraints
230            this.__circularReference4a = circularReference4a;
231            if (isMetafacadePropertyCachingEnabled())
232            {
233                this.__circularReference4aSet = true;
234            }
235        }
236        return circularReference4a;
237    }
238
239   /**
240    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationConstantValue()
241    * @return int
242    */
243    protected abstract int handleGetTransformationConstantValue();
244
245    private int __transformationConstantValue5a;
246    private boolean __transformationConstantValue5aSet = false;
247
248    /**
249     * Gets the transformation constant integer value.
250     * @return (int)handleGetTransformationConstantValue()
251     */
252    public final int getTransformationConstantValue()
253    {
254        int transformationConstantValue5a = this.__transformationConstantValue5a;
255        if (!this.__transformationConstantValue5aSet)
256        {
257            // transformationConstantValue has no pre constraints
258            transformationConstantValue5a = handleGetTransformationConstantValue();
259            // transformationConstantValue has no post constraints
260            this.__transformationConstantValue5a = transformationConstantValue5a;
261            if (isMetafacadePropertyCachingEnabled())
262            {
263                this.__transformationConstantValue5aSet = true;
264            }
265        }
266        return transformationConstantValue5a;
267    }
268
269   /**
270    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationToCollectionMethodName()
271    * @return String
272    */
273    protected abstract String handleGetTransformationToCollectionMethodName();
274
275    private String __transformationToCollectionMethodName6a;
276    private boolean __transformationToCollectionMethodName6aSet = false;
277
278    /**
279     * Returns the name of the method for transforming the contents of a collection.
280     * @return (String)handleGetTransformationToCollectionMethodName()
281     */
282    public final String getTransformationToCollectionMethodName()
283    {
284        String transformationToCollectionMethodName6a = this.__transformationToCollectionMethodName6a;
285        if (!this.__transformationToCollectionMethodName6aSet)
286        {
287            // transformationToCollectionMethodName has no pre constraints
288            transformationToCollectionMethodName6a = handleGetTransformationToCollectionMethodName();
289            // transformationToCollectionMethodName has no post constraints
290            this.__transformationToCollectionMethodName6a = transformationToCollectionMethodName6a;
291            if (isMetafacadePropertyCachingEnabled())
292            {
293                this.__transformationToCollectionMethodName6aSet = true;
294            }
295        }
296        return transformationToCollectionMethodName6a;
297    }
298
299   /**
300    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getDaoName()
301    * @return String
302    */
303    protected abstract String handleGetDaoName();
304
305    private String __daoName7a;
306    private boolean __daoName7aSet = false;
307
308    /**
309     * The name given to a DAO reference.
310     * @return (String)handleGetDaoName()
311     */
312    public final String getDaoName()
313    {
314        String daoName7a = this.__daoName7a;
315        if (!this.__daoName7aSet)
316        {
317            // daoName has no pre constraints
318            daoName7a = handleGetDaoName();
319            // daoName has no post constraints
320            this.__daoName7a = daoName7a;
321            if (isMetafacadePropertyCachingEnabled())
322            {
323                this.__daoName7aSet = true;
324            }
325        }
326        return daoName7a;
327    }
328
329   /**
330    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getDaoGetterName()
331    * @return String
332    */
333    protected abstract String handleGetDaoGetterName();
334
335    private String __daoGetterName8a;
336    private boolean __daoGetterName8aSet = false;
337
338    /**
339     * The name of the DAO reference getter name.
340     * @return (String)handleGetDaoGetterName()
341     */
342    public final String getDaoGetterName()
343    {
344        String daoGetterName8a = this.__daoGetterName8a;
345        if (!this.__daoGetterName8aSet)
346        {
347            // daoGetterName has no pre constraints
348            daoGetterName8a = handleGetDaoGetterName();
349            // daoGetterName has no post constraints
350            this.__daoGetterName8a = daoGetterName8a;
351            if (isMetafacadePropertyCachingEnabled())
352            {
353                this.__daoGetterName8aSet = true;
354            }
355        }
356        return daoGetterName8a;
357    }
358
359   /**
360    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getDaoSetterName()
361    * @return String
362    */
363    protected abstract String handleGetDaoSetterName();
364
365    private String __daoSetterName9a;
366    private boolean __daoSetterName9aSet = false;
367
368    /**
369     * The DAO reference setter's name.
370     * @return (String)handleGetDaoSetterName()
371     */
372    public final String getDaoSetterName()
373    {
374        String daoSetterName9a = this.__daoSetterName9a;
375        if (!this.__daoSetterName9aSet)
376        {
377            // daoSetterName has no pre constraints
378            daoSetterName9a = handleGetDaoSetterName();
379            // daoSetterName has no post constraints
380            this.__daoSetterName9a = daoSetterName9a;
381            if (isMetafacadePropertyCachingEnabled())
382            {
383                this.__daoSetterName9aSet = true;
384            }
385        }
386        return daoSetterName9a;
387    }
388
389   /**
390    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationToEntityCollectionMethodName()
391    * @return String
392    */
393    protected abstract String handleGetTransformationToEntityCollectionMethodName();
394
395    private String __transformationToEntityCollectionMethodName10a;
396    private boolean __transformationToEntityCollectionMethodName10aSet = false;
397
398    /**
399     * The method name that performs the value object collection to entity collection
400     * transformation.
401     * @return (String)handleGetTransformationToEntityCollectionMethodName()
402     */
403    public final String getTransformationToEntityCollectionMethodName()
404    {
405        String transformationToEntityCollectionMethodName10a = this.__transformationToEntityCollectionMethodName10a;
406        if (!this.__transformationToEntityCollectionMethodName10aSet)
407        {
408            // transformationToEntityCollectionMethodName has no pre constraints
409            transformationToEntityCollectionMethodName10a = handleGetTransformationToEntityCollectionMethodName();
410            // transformationToEntityCollectionMethodName has no post constraints
411            this.__transformationToEntityCollectionMethodName10a = transformationToEntityCollectionMethodName10a;
412            if (isMetafacadePropertyCachingEnabled())
413            {
414                this.__transformationToEntityCollectionMethodName10aSet = true;
415            }
416        }
417        return transformationToEntityCollectionMethodName10a;
418    }
419
420   /**
421    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getTransformationToEntityMethodName()
422    * @return String
423    */
424    protected abstract String handleGetTransformationToEntityMethodName();
425
426    private String __transformationToEntityMethodName11a;
427    private boolean __transformationToEntityMethodName11aSet = false;
428
429    /**
430     * The name of the "to entity" transformation method name.
431     * @return (String)handleGetTransformationToEntityMethodName()
432     */
433    public final String getTransformationToEntityMethodName()
434    {
435        String transformationToEntityMethodName11a = this.__transformationToEntityMethodName11a;
436        if (!this.__transformationToEntityMethodName11aSet)
437        {
438            // transformationToEntityMethodName has no pre constraints
439            transformationToEntityMethodName11a = handleGetTransformationToEntityMethodName();
440            // transformationToEntityMethodName has no post constraints
441            this.__transformationToEntityMethodName11a = transformationToEntityMethodName11a;
442            if (isMetafacadePropertyCachingEnabled())
443            {
444                this.__transformationToEntityMethodName11aSet = true;
445            }
446        }
447        return transformationToEntityMethodName11a;
448    }
449
450   /**
451    * @see org.andromda.cartridges.ejb3.metafacades.EJB3DependencyFacade#getValueObjectToEntityTransformerName()
452    * @return String
453    */
454    protected abstract String handleGetValueObjectToEntityTransformerName();
455
456    private String __valueObjectToEntityTransformerName12a;
457    private boolean __valueObjectToEntityTransformerName12aSet = false;
458
459    /**
460     * The name of the class that performs the value object to entity transformation.
461     * @return (String)handleGetValueObjectToEntityTransformerName()
462     */
463    public final String getValueObjectToEntityTransformerName()
464    {
465        String valueObjectToEntityTransformerName12a = this.__valueObjectToEntityTransformerName12a;
466        if (!this.__valueObjectToEntityTransformerName12aSet)
467        {
468            // valueObjectToEntityTransformerName has no pre constraints
469            valueObjectToEntityTransformerName12a = handleGetValueObjectToEntityTransformerName();
470            // valueObjectToEntityTransformerName has no post constraints
471            this.__valueObjectToEntityTransformerName12a = valueObjectToEntityTransformerName12a;
472            if (isMetafacadePropertyCachingEnabled())
473            {
474                this.__valueObjectToEntityTransformerName12aSet = true;
475            }
476        }
477        return valueObjectToEntityTransformerName12a;
478    }
479
480    /**
481     * @return true
482     * @see DependencyFacade
483     */
484    public boolean isDependencyFacadeMetaType()
485    {
486        return true;
487    }
488
489    /**
490     * @return true
491     * @see ModelElementFacade
492     */
493    public boolean isModelElementFacadeMetaType()
494    {
495        return true;
496    }
497
498    // ----------- delegates to DependencyFacade ------------
499    /**
500     * The "getter" name for this dependency.
501     * @see DependencyFacade#getGetterName()
502     */
503    public String getGetterName()
504    {
505        return this.getSuperDependencyFacade().getGetterName();
506    }
507
508    /**
509     * The "setter" name for this dependency.
510     * @see DependencyFacade#getSetterName()
511     */
512    public String getSetterName()
513    {
514        return this.getSuperDependencyFacade().getSetterName();
515    }
516
517    /**
518     * The source element of this dependency.
519     * @see DependencyFacade#getSourceElement()
520     */
521    public ModelElementFacade getSourceElement()
522    {
523        return this.getSuperDependencyFacade().getSourceElement();
524    }
525
526    /**
527     * Gets the element to which the dependencies belong.
528     * @see DependencyFacade#getTargetElement()
529     */
530    public ModelElementFacade getTargetElement()
531    {
532        return this.getSuperDependencyFacade().getTargetElement();
533    }
534
535    /**
536     * Copies all tagged values from the given ModelElementFacade to this model element facade.
537     * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
538     */
539    public void copyTaggedValues(ModelElementFacade element)
540    {
541        this.getSuperDependencyFacade().copyTaggedValues(element);
542    }
543
544    /**
545     * Finds the tagged value with the specified 'tagName'. In case there are more values the first
546     * one found will be returned.
547     * @see ModelElementFacade#findTaggedValue(String tagName)
548     */
549    public Object findTaggedValue(String tagName)
550    {
551        return this.getSuperDependencyFacade().findTaggedValue(tagName);
552    }
553
554    /**
555     * Returns all the values for the tagged value with the specified name. The returned collection
556     * will contains only String instances, or will be empty. Never null.
557     * @see ModelElementFacade#findTaggedValues(String tagName)
558     */
559    public Collection<Object> findTaggedValues(String tagName)
560    {
561        return this.getSuperDependencyFacade().findTaggedValues(tagName);
562    }
563
564    /**
565     * Returns the fully qualified name of the model element. The fully qualified name includes
566     * complete package qualified name of the underlying model element. The templates parameter will
567     * be replaced by the correct one given the binding relation of the parameter to this element.
568     * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
569     */
570    public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
571    {
572        return this.getSuperDependencyFacade().getBindedFullyQualifiedName(bindedElement);
573    }
574
575    /**
576     * Gets all constraints belonging to the model element.
577     * @see ModelElementFacade#getConstraints()
578     */
579    public Collection<ConstraintFacade> getConstraints()
580    {
581        return this.getSuperDependencyFacade().getConstraints();
582    }
583
584    /**
585     * Returns the constraints of the argument kind that have been placed onto this model. Typical
586     * kinds are "inv", "pre" and "post". Other kinds are possible.
587     * @see ModelElementFacade#getConstraints(String kind)
588     */
589    public Collection<ConstraintFacade> getConstraints(String kind)
590    {
591        return this.getSuperDependencyFacade().getConstraints(kind);
592    }
593
594    /**
595     * Gets the documentation for the model element, The indent argument is prefixed to each line.
596     * By default this method wraps lines after 64 characters.
597     * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
598     * @see ModelElementFacade#getDocumentation(String indent)
599     */
600    public String getDocumentation(String indent)
601    {
602        return this.getSuperDependencyFacade().getDocumentation(indent);
603    }
604
605    /**
606     * This method returns the documentation for this model element, with the lines wrapped after
607     * the specified number of characters, values of less than 1 will indicate no line wrapping is
608     * required. By default paragraphs are returned as HTML.
609     * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
610     * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
611     */
612    public String getDocumentation(String indent, int lineLength)
613    {
614        return this.getSuperDependencyFacade().getDocumentation(indent, lineLength);
615    }
616
617    /**
618     * This method returns the documentation for this model element, with the lines wrapped after
619     * the specified number of characters, values of less than 1 will indicate no line wrapping is
620     * required. HTML style determines if HTML Escaping is applied.
621     * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
622     */
623    public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
624    {
625        return this.getSuperDependencyFacade().getDocumentation(indent, lineLength, htmlStyle);
626    }
627
628    /**
629     * The fully qualified name of this model element.
630     * @see ModelElementFacade#getFullyQualifiedName()
631     */
632    public String getFullyQualifiedName()
633    {
634        return this.getSuperDependencyFacade().getFullyQualifiedName();
635    }
636
637    /**
638     * Returns the fully qualified name of the model element. The fully qualified name includes
639     * complete package qualified name of the underlying model element.  If modelName is true, then
640     * the original name of the model element (the name contained within the model) will be the name
641     * returned, otherwise a name from a language mapping will be returned.
642     * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
643     */
644    public String getFullyQualifiedName(boolean modelName)
645    {
646        return this.getSuperDependencyFacade().getFullyQualifiedName(modelName);
647    }
648
649    /**
650     * Returns the fully qualified name as a path, the returned value always starts with out a slash
651     * '/'.
652     * @see ModelElementFacade#getFullyQualifiedNamePath()
653     */
654    public String getFullyQualifiedNamePath()
655    {
656        return this.getSuperDependencyFacade().getFullyQualifiedNamePath();
657    }
658
659    /**
660     * Gets the unique identifier of the underlying model element.
661     * @see ModelElementFacade#getId()
662     */
663    public String getId()
664    {
665        return this.getSuperDependencyFacade().getId();
666    }
667
668    /**
669     * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
670     * are not represented by other properties, i.e. native, transient, volatile, synchronized,
671     * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
672     * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
673     * JDK5 compiler level.
674     * @see ModelElementFacade#getKeywords()
675     */
676    public Collection<String> getKeywords()
677    {
678        return this.getSuperDependencyFacade().getKeywords();
679    }
680
681    /**
682     * UML2: Retrieves a localized label for this named element.
683     * @see ModelElementFacade#getLabel()
684     */
685    public String getLabel()
686    {
687        return this.getSuperDependencyFacade().getLabel();
688    }
689
690    /**
691     * The language mappings that have been set for this model element.
692     * @see ModelElementFacade#getLanguageMappings()
693     */
694    public TypeMappings getLanguageMappings()
695    {
696        return this.getSuperDependencyFacade().getLanguageMappings();
697    }
698
699    /**
700     * Return the model containing this model element (multiple models may be loaded and processed
701     * at the same time).
702     * @see ModelElementFacade#getModel()
703     */
704    public ModelFacade getModel()
705    {
706        return this.getSuperDependencyFacade().getModel();
707    }
708
709    /**
710     * The name of the model element.
711     * @see ModelElementFacade#getName()
712     */
713    public String getName()
714    {
715        return this.getSuperDependencyFacade().getName();
716    }
717
718    /**
719     * Gets the package to which this model element belongs.
720     * @see ModelElementFacade#getPackage()
721     */
722    public ModelElementFacade getPackage()
723    {
724        return this.getSuperDependencyFacade().getPackage();
725    }
726
727    /**
728     * The name of this model element's package.
729     * @see ModelElementFacade#getPackageName()
730     */
731    public String getPackageName()
732    {
733        return this.getSuperDependencyFacade().getPackageName();
734    }
735
736    /**
737     * Gets the package name (optionally providing the ability to retrieve the model name and not
738     * the mapped name).
739     * @see ModelElementFacade#getPackageName(boolean modelName)
740     */
741    public String getPackageName(boolean modelName)
742    {
743        return this.getSuperDependencyFacade().getPackageName(modelName);
744    }
745
746    /**
747     * Returns the package as a path, the returned value always starts with out a slash '/'.
748     * @see ModelElementFacade#getPackagePath()
749     */
750    public String getPackagePath()
751    {
752        return this.getSuperDependencyFacade().getPackagePath();
753    }
754
755    /**
756     * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
757     * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
758     * the names of the containing namespaces starting at the root of the hierarchy and ending with
759     * the name of the NamedElement itself.
760     * @see ModelElementFacade#getQualifiedName()
761     */
762    public String getQualifiedName()
763    {
764        return this.getSuperDependencyFacade().getQualifiedName();
765    }
766
767    /**
768     * Gets the root package for the model element.
769     * @see ModelElementFacade#getRootPackage()
770     */
771    public PackageFacade getRootPackage()
772    {
773        return this.getSuperDependencyFacade().getRootPackage();
774    }
775
776    /**
777     * Gets the dependencies for which this model element is the source.
778     * @see ModelElementFacade#getSourceDependencies()
779     */
780    public Collection<DependencyFacade> getSourceDependencies()
781    {
782        return this.getSuperDependencyFacade().getSourceDependencies();
783    }
784
785    /**
786     * If this model element is the context of an activity graph, this represents that activity
787     * graph.
788     * @see ModelElementFacade#getStateMachineContext()
789     */
790    public StateMachineFacade getStateMachineContext()
791    {
792        return this.getSuperDependencyFacade().getStateMachineContext();
793    }
794
795    /**
796     * The collection of ALL stereotype names for this model element.
797     * @see ModelElementFacade#getStereotypeNames()
798     */
799    public Collection<String> getStereotypeNames()
800    {
801        return this.getSuperDependencyFacade().getStereotypeNames();
802    }
803
804    /**
805     * Gets all stereotypes for this model element.
806     * @see ModelElementFacade#getStereotypes()
807     */
808    public Collection<StereotypeFacade> getStereotypes()
809    {
810        return this.getSuperDependencyFacade().getStereotypes();
811    }
812
813    /**
814     * Return the TaggedValues associated with this model element, under all stereotypes.
815     * @see ModelElementFacade#getTaggedValues()
816     */
817    public Collection<TaggedValueFacade> getTaggedValues()
818    {
819        return this.getSuperDependencyFacade().getTaggedValues();
820    }
821
822    /**
823     * Gets the dependencies for which this model element is the target.
824     * @see ModelElementFacade#getTargetDependencies()
825     */
826    public Collection<DependencyFacade> getTargetDependencies()
827    {
828        return this.getSuperDependencyFacade().getTargetDependencies();
829    }
830
831    /**
832     * Get the template parameter for this model element having the parameterName
833     * @see ModelElementFacade#getTemplateParameter(String parameterName)
834     */
835    public Object getTemplateParameter(String parameterName)
836    {
837        return this.getSuperDependencyFacade().getTemplateParameter(parameterName);
838    }
839
840    /**
841     * Get the template parameters for this model element
842     * @see ModelElementFacade#getTemplateParameters()
843     */
844    public Collection<TemplateParameterFacade> getTemplateParameters()
845    {
846        return this.getSuperDependencyFacade().getTemplateParameters();
847    }
848
849    /**
850     * The visibility (i.e. public, private, protected or package) of the model element, will
851     * attempt a lookup for these values in the language mappings (if any).
852     * @see ModelElementFacade#getVisibility()
853     */
854    public String getVisibility()
855    {
856        return this.getSuperDependencyFacade().getVisibility();
857    }
858
859    /**
860     * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
861     * is taken into account when searching for the stereotype), false otherwise.
862     * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
863     */
864    public boolean hasExactStereotype(String stereotypeName)
865    {
866        return this.getSuperDependencyFacade().hasExactStereotype(stereotypeName);
867    }
868
869    /**
870     * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
871     * pipe, semicolon, or << >>
872     * @see ModelElementFacade#hasKeyword(String keywordName)
873     */
874    public boolean hasKeyword(String keywordName)
875    {
876        return this.getSuperDependencyFacade().hasKeyword(keywordName);
877    }
878
879    /**
880     * Returns true if the model element has the specified stereotype.  If the stereotype itself
881     * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
882     * one of the stereotype's ancestors has a matching name this method will return true, false
883     * otherwise.
884     * For example, if we have a certain stereotype called <<exception>> and a model element has a
885     * stereotype called <<applicationException>> which extends <<exception>>, when calling this
886     * method with 'stereotypeName' defined as 'exception' the method would return true since
887     * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
888     * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
889     * @see ModelElementFacade#hasStereotype(String stereotypeName)
890     */
891    public boolean hasStereotype(String stereotypeName)
892    {
893        return this.getSuperDependencyFacade().hasStereotype(stereotypeName);
894    }
895
896    /**
897     * True if there are target dependencies from this element that are instances of BindingFacade.
898     * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
899     * @see ModelElementFacade#isBindingDependenciesPresent()
900     */
901    public boolean isBindingDependenciesPresent()
902    {
903        return this.getSuperDependencyFacade().isBindingDependenciesPresent();
904    }
905
906    /**
907     * Indicates if any constraints are present on this model element.
908     * @see ModelElementFacade#isConstraintsPresent()
909     */
910    public boolean isConstraintsPresent()
911    {
912        return this.getSuperDependencyFacade().isConstraintsPresent();
913    }
914
915    /**
916     * Indicates if any documentation is present on this model element.
917     * @see ModelElementFacade#isDocumentationPresent()
918     */
919    public boolean isDocumentationPresent()
920    {
921        return this.getSuperDependencyFacade().isDocumentationPresent();
922    }
923
924    /**
925     * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
926     * @see ModelElementFacade#isReservedWord()
927     */
928    public boolean isReservedWord()
929    {
930        return this.getSuperDependencyFacade().isReservedWord();
931    }
932
933    /**
934     * True is there are template parameters on this model element. For UML2, applies to Class,
935     * Operation, Property, and Parameter.
936     * @see ModelElementFacade#isTemplateParametersPresent()
937     */
938    public boolean isTemplateParametersPresent()
939    {
940        return this.getSuperDependencyFacade().isTemplateParametersPresent();
941    }
942
943    /**
944     * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
945     * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
946     * Enumerations and Interfaces, optionally applies on other model elements.
947     * @see ModelElementFacade#isValidIdentifierName()
948     */
949    public boolean isValidIdentifierName()
950    {
951        return this.getSuperDependencyFacade().isValidIdentifierName();
952    }
953
954    /**
955     * Searches for the constraint with the specified 'name' on this model element, and if found
956     * translates it using the specified 'translation' from a translation library discovered by the
957     * framework.
958     * @see ModelElementFacade#translateConstraint(String name, String translation)
959     */
960    public String translateConstraint(String name, String translation)
961    {
962        return this.getSuperDependencyFacade().translateConstraint(name, translation);
963    }
964
965    /**
966     * Translates all constraints belonging to this model element with the given 'translation'.
967     * @see ModelElementFacade#translateConstraints(String translation)
968     */
969    public String[] translateConstraints(String translation)
970    {
971        return this.getSuperDependencyFacade().translateConstraints(translation);
972    }
973
974    /**
975     * Translates the constraints of the specified 'kind' belonging to this model element.
976     * @see ModelElementFacade#translateConstraints(String kind, String translation)
977     */
978    public String[] translateConstraints(String kind, String translation)
979    {
980        return this.getSuperDependencyFacade().translateConstraints(kind, translation);
981    }
982
983    /**
984     * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
985     */
986    @Override
987    public void initialize()
988    {
989        this.getSuperDependencyFacade().initialize();
990    }
991
992    /**
993     * @return Object getSuperDependencyFacade().getValidationOwner()
994     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
995     */
996    @Override
997    public Object getValidationOwner()
998    {
999        Object owner = this.getSuperDependencyFacade().getValidationOwner();
1000        return owner;
1001    }
1002
1003    /**
1004     * @return String getSuperDependencyFacade().getValidationName()
1005     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1006     */
1007    @Override
1008    public String getValidationName()
1009    {
1010        String name = this.getSuperDependencyFacade().getValidationName();
1011        return name;
1012    }
1013
1014    /**
1015     * @param validationMessages Collection<ModelValidationMessage>
1016     * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1017     */
1018    @Override
1019    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1020    {
1021        this.getSuperDependencyFacade().validateInvariants(validationMessages);
1022    }
1023
1024    /**
1025     * The property that stores the name of the metafacade.
1026     */
1027    private static final String NAME_PROPERTY = "name";
1028    private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1029
1030    /**
1031     * @see Object#toString()
1032     */
1033    @Override
1034    public String toString()
1035    {
1036        final StringBuilder toString = new StringBuilder(this.getClass().getName());
1037        toString.append("[");
1038        try
1039        {
1040            toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1041        }
1042        catch (final Throwable tryAgain)
1043        {
1044            try
1045            {
1046                toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1047            }
1048            catch (final Throwable ignore)
1049            {
1050                // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1051            }
1052        }
1053        toString.append("]");
1054        return toString.toString();
1055    }
1056}