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 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.ClassifierFacade;
013import org.andromda.metafacades.uml.ConstraintFacade;
014import org.andromda.metafacades.uml.DependencyFacade;
015import org.andromda.metafacades.uml.Destination;
016import org.andromda.metafacades.uml.ModelElementFacade;
017import org.andromda.metafacades.uml.ModelFacade;
018import org.andromda.metafacades.uml.OperationFacade;
019import org.andromda.metafacades.uml.PackageFacade;
020import org.andromda.metafacades.uml.ParameterFacade;
021import org.andromda.metafacades.uml.Role;
022import org.andromda.metafacades.uml.Service;
023import org.andromda.metafacades.uml.ServiceOperation;
024import org.andromda.metafacades.uml.StateMachineFacade;
025import org.andromda.metafacades.uml.StereotypeFacade;
026import org.andromda.metafacades.uml.TaggedValueFacade;
027import org.andromda.metafacades.uml.TemplateParameterFacade;
028import org.andromda.metafacades.uml.TypeMappings;
029
030/**
031 * TODO: Model Documentation for
032 * org.andromda.cartridges.hibernate.metafacades.HibernateServiceOperation
033 * MetafacadeLogic for HibernateServiceOperation
034 *
035 * @see HibernateServiceOperation
036 */
037public abstract class HibernateServiceOperationLogic
038    extends MetafacadeBase
039    implements HibernateServiceOperation
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 HibernateServiceOperationLogic(Object metaObjectIn, String context)
052    {
053        super(metaObjectIn, getContext(context));
054        this.superServiceOperation =
055           (ServiceOperation)
056            MetafacadeFactory.getInstance().createFacadeImpl(
057                    "org.andromda.metafacades.uml.ServiceOperation",
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 HibernateServiceOperation 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.HibernateServiceOperation";
073        }
074        return context;
075    }
076
077    private ServiceOperation superServiceOperation;
078    private boolean superServiceOperationInitialized = false;
079
080    /**
081     * Gets the ServiceOperation parent instance.
082     * @return this.superServiceOperation ServiceOperation
083     */
084    private ServiceOperation getSuperServiceOperation()
085    {
086        if (!this.superServiceOperationInitialized)
087        {
088            ((MetafacadeBase)this.superServiceOperation).setMetafacadeContext(this.getMetafacadeContext());
089            this.superServiceOperationInitialized = true;
090        }
091        return this.superServiceOperation;
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.superServiceOperationInitialized)
106            {
107                ((MetafacadeBase)this.superServiceOperation).resetMetafacadeContext(context);
108            }
109        }
110    }
111
112    /**
113     * @return boolean true always
114     * @see HibernateServiceOperation
115     */
116    public boolean isHibernateServiceOperationMetaType()
117    {
118        return true;
119    }
120
121    // --------------- attributes ---------------------
122
123   /**
124    * @see org.andromda.cartridges.hibernate.metafacades.HibernateServiceOperation#getTransactionType()
125    * @return String
126    */
127    protected abstract String handleGetTransactionType();
128
129    /**
130     * Stores the EJB transaction type for this service operation.
131     * @return (String)handleGetTransactionType()
132     */
133    public final String getTransactionType()
134    {
135        String transactionType1a = null;
136        // transactionType has no pre constraints
137        transactionType1a = handleGetTransactionType();
138        // transactionType has no post constraints
139        return transactionType1a;
140    }
141
142    /**
143     * @return true
144     * @see ServiceOperation
145     */
146    public boolean isServiceOperationMetaType()
147    {
148        return true;
149    }
150
151    /**
152     * @return true
153     * @see OperationFacade
154     */
155    public boolean isOperationFacadeMetaType()
156    {
157        return true;
158    }
159
160    /**
161     * @return true
162     * @see ModelElementFacade
163     */
164    public boolean isModelElementFacadeMetaType()
165    {
166        return true;
167    }
168
169    // ----------- delegates to ServiceOperation ------------
170    /**
171     * Copies all tagged values from the given ModelElementFacade to this model element facade.
172     * @see ModelElementFacade#copyTaggedValues(ModelElementFacade element)
173     */
174    public void copyTaggedValues(ModelElementFacade element)
175    {
176        this.getSuperServiceOperation().copyTaggedValues(element);
177    }
178
179    /**
180     * Finds the tagged value with the specified 'tagName'. In case there are more values the first
181     * one found will be returned.
182     * @see ModelElementFacade#findTaggedValue(String tagName)
183     */
184    public Object findTaggedValue(String tagName)
185    {
186        return this.getSuperServiceOperation().findTaggedValue(tagName);
187    }
188
189    /**
190     * Returns all the values for the tagged value with the specified name. The returned collection
191     * will contains only String instances, or will be empty. Never null.
192     * @see ModelElementFacade#findTaggedValues(String tagName)
193     */
194    public Collection<Object> findTaggedValues(String tagName)
195    {
196        return this.getSuperServiceOperation().findTaggedValues(tagName);
197    }
198
199    /**
200     * Returns the fully qualified name of the model element. The fully qualified name includes
201     * complete package qualified name of the underlying model element. The templates parameter will
202     * be replaced by the correct one given the binding relation of the parameter to this element.
203     * @see ModelElementFacade#getBindedFullyQualifiedName(ModelElementFacade bindedElement)
204     */
205    public String getBindedFullyQualifiedName(ModelElementFacade bindedElement)
206    {
207        return this.getSuperServiceOperation().getBindedFullyQualifiedName(bindedElement);
208    }
209
210    /**
211     * Gets all constraints belonging to the model element.
212     * @see ModelElementFacade#getConstraints()
213     */
214    public Collection<ConstraintFacade> getConstraints()
215    {
216        return this.getSuperServiceOperation().getConstraints();
217    }
218
219    /**
220     * Returns the constraints of the argument kind that have been placed onto this model. Typical
221     * kinds are "inv", "pre" and "post". Other kinds are possible.
222     * @see ModelElementFacade#getConstraints(String kind)
223     */
224    public Collection<ConstraintFacade> getConstraints(String kind)
225    {
226        return this.getSuperServiceOperation().getConstraints(kind);
227    }
228
229    /**
230     * Gets the documentation for the model element, The indent argument is prefixed to each line.
231     * By default this method wraps lines after 64 characters.
232     * This method is equivalent to <code>getDocumentation(indent, 64)</code>.
233     * @see ModelElementFacade#getDocumentation(String indent)
234     */
235    public String getDocumentation(String indent)
236    {
237        return this.getSuperServiceOperation().getDocumentation(indent);
238    }
239
240    /**
241     * This method returns the documentation for this model element, with the lines wrapped after
242     * the specified number of characters, values of less than 1 will indicate no line wrapping is
243     * required. By default paragraphs are returned as HTML.
244     * This method is equivalent to <code>getDocumentation(indent, lineLength, true)</code>.
245     * @see ModelElementFacade#getDocumentation(String indent, int lineLength)
246     */
247    public String getDocumentation(String indent, int lineLength)
248    {
249        return this.getSuperServiceOperation().getDocumentation(indent, lineLength);
250    }
251
252    /**
253     * This method returns the documentation for this model element, with the lines wrapped after
254     * the specified number of characters, values of less than 1 will indicate no line wrapping is
255     * required. HTML style determines if HTML Escaping is applied.
256     * @see ModelElementFacade#getDocumentation(String indent, int lineLength, boolean htmlStyle)
257     */
258    public String getDocumentation(String indent, int lineLength, boolean htmlStyle)
259    {
260        return this.getSuperServiceOperation().getDocumentation(indent, lineLength, htmlStyle);
261    }
262
263    /**
264     * The fully qualified name of this model element.
265     * @see ModelElementFacade#getFullyQualifiedName()
266     */
267    public String getFullyQualifiedName()
268    {
269        return this.getSuperServiceOperation().getFullyQualifiedName();
270    }
271
272    /**
273     * Returns the fully qualified name of the model element. The fully qualified name includes
274     * complete package qualified name of the underlying model element.  If modelName is true, then
275     * the original name of the model element (the name contained within the model) will be the name
276     * returned, otherwise a name from a language mapping will be returned.
277     * @see ModelElementFacade#getFullyQualifiedName(boolean modelName)
278     */
279    public String getFullyQualifiedName(boolean modelName)
280    {
281        return this.getSuperServiceOperation().getFullyQualifiedName(modelName);
282    }
283
284    /**
285     * Returns the fully qualified name as a path, the returned value always starts with out a slash
286     * '/'.
287     * @see ModelElementFacade#getFullyQualifiedNamePath()
288     */
289    public String getFullyQualifiedNamePath()
290    {
291        return this.getSuperServiceOperation().getFullyQualifiedNamePath();
292    }
293
294    /**
295     * Gets the unique identifier of the underlying model element.
296     * @see ModelElementFacade#getId()
297     */
298    public String getId()
299    {
300        return this.getSuperServiceOperation().getId();
301    }
302
303    /**
304     * UML2: Retrieves the keywords for this element. Used to modify implementation properties which
305     * are not represented by other properties, i.e. native, transient, volatile, synchronized,
306     * (added annotations) override, deprecated. Can also be used to suppress compiler warnings:
307     * (added annotations) unchecked, fallthrough, path, serial, finally, all. Annotations require
308     * JDK5 compiler level.
309     * @see ModelElementFacade#getKeywords()
310     */
311    public Collection<String> getKeywords()
312    {
313        return this.getSuperServiceOperation().getKeywords();
314    }
315
316    /**
317     * UML2: Retrieves a localized label for this named element.
318     * @see ModelElementFacade#getLabel()
319     */
320    public String getLabel()
321    {
322        return this.getSuperServiceOperation().getLabel();
323    }
324
325    /**
326     * The language mappings that have been set for this model element.
327     * @see ModelElementFacade#getLanguageMappings()
328     */
329    public TypeMappings getLanguageMappings()
330    {
331        return this.getSuperServiceOperation().getLanguageMappings();
332    }
333
334    /**
335     * Return the model containing this model element (multiple models may be loaded and processed
336     * at the same time).
337     * @see ModelElementFacade#getModel()
338     */
339    public ModelFacade getModel()
340    {
341        return this.getSuperServiceOperation().getModel();
342    }
343
344    /**
345     * The name of the model element.
346     * @see ModelElementFacade#getName()
347     */
348    public String getName()
349    {
350        return this.getSuperServiceOperation().getName();
351    }
352
353    /**
354     * Gets the package to which this model element belongs.
355     * @see ModelElementFacade#getPackage()
356     */
357    public ModelElementFacade getPackage()
358    {
359        return this.getSuperServiceOperation().getPackage();
360    }
361
362    /**
363     * The name of this model element's package.
364     * @see ModelElementFacade#getPackageName()
365     */
366    public String getPackageName()
367    {
368        return this.getSuperServiceOperation().getPackageName();
369    }
370
371    /**
372     * Gets the package name (optionally providing the ability to retrieve the model name and not
373     * the mapped name).
374     * @see ModelElementFacade#getPackageName(boolean modelName)
375     */
376    public String getPackageName(boolean modelName)
377    {
378        return this.getSuperServiceOperation().getPackageName(modelName);
379    }
380
381    /**
382     * Returns the package as a path, the returned value always starts with out a slash '/'.
383     * @see ModelElementFacade#getPackagePath()
384     */
385    public String getPackagePath()
386    {
387        return this.getSuperServiceOperation().getPackagePath();
388    }
389
390    /**
391     * UML2: Returns the value of the 'Qualified Name' attribute. A name which allows the
392     * NamedElement to be identified within a hierarchy of nested Namespaces. It is constructed from
393     * the names of the containing namespaces starting at the root of the hierarchy and ending with
394     * the name of the NamedElement itself.
395     * @see ModelElementFacade#getQualifiedName()
396     */
397    public String getQualifiedName()
398    {
399        return this.getSuperServiceOperation().getQualifiedName();
400    }
401
402    /**
403     * Gets the root package for the model element.
404     * @see ModelElementFacade#getRootPackage()
405     */
406    public PackageFacade getRootPackage()
407    {
408        return this.getSuperServiceOperation().getRootPackage();
409    }
410
411    /**
412     * Gets the dependencies for which this model element is the source.
413     * @see ModelElementFacade#getSourceDependencies()
414     */
415    public Collection<DependencyFacade> getSourceDependencies()
416    {
417        return this.getSuperServiceOperation().getSourceDependencies();
418    }
419
420    /**
421     * If this model element is the context of an activity graph, this represents that activity
422     * graph.
423     * @see ModelElementFacade#getStateMachineContext()
424     */
425    public StateMachineFacade getStateMachineContext()
426    {
427        return this.getSuperServiceOperation().getStateMachineContext();
428    }
429
430    /**
431     * The collection of ALL stereotype names for this model element.
432     * @see ModelElementFacade#getStereotypeNames()
433     */
434    public Collection<String> getStereotypeNames()
435    {
436        return this.getSuperServiceOperation().getStereotypeNames();
437    }
438
439    /**
440     * Gets all stereotypes for this model element.
441     * @see ModelElementFacade#getStereotypes()
442     */
443    public Collection<StereotypeFacade> getStereotypes()
444    {
445        return this.getSuperServiceOperation().getStereotypes();
446    }
447
448    /**
449     * Return the TaggedValues associated with this model element, under all stereotypes.
450     * @see ModelElementFacade#getTaggedValues()
451     */
452    public Collection<TaggedValueFacade> getTaggedValues()
453    {
454        return this.getSuperServiceOperation().getTaggedValues();
455    }
456
457    /**
458     * Gets the dependencies for which this model element is the target.
459     * @see ModelElementFacade#getTargetDependencies()
460     */
461    public Collection<DependencyFacade> getTargetDependencies()
462    {
463        return this.getSuperServiceOperation().getTargetDependencies();
464    }
465
466    /**
467     * Get the template parameter for this model element having the parameterName
468     * @see ModelElementFacade#getTemplateParameter(String parameterName)
469     */
470    public Object getTemplateParameter(String parameterName)
471    {
472        return this.getSuperServiceOperation().getTemplateParameter(parameterName);
473    }
474
475    /**
476     * Get the template parameters for this model element
477     * @see ModelElementFacade#getTemplateParameters()
478     */
479    public Collection<TemplateParameterFacade> getTemplateParameters()
480    {
481        return this.getSuperServiceOperation().getTemplateParameters();
482    }
483
484    /**
485     * The visibility (i.e. public, private, protected or package) of the model element, will
486     * attempt a lookup for these values in the language mappings (if any).
487     * @see ModelElementFacade#getVisibility()
488     */
489    public String getVisibility()
490    {
491        return this.getSuperServiceOperation().getVisibility();
492    }
493
494    /**
495     * Returns true if the model element has the exact stereotype (meaning no stereotype inheritance
496     * is taken into account when searching for the stereotype), false otherwise.
497     * @see ModelElementFacade#hasExactStereotype(String stereotypeName)
498     */
499    public boolean hasExactStereotype(String stereotypeName)
500    {
501        return this.getSuperServiceOperation().hasExactStereotype(stereotypeName);
502    }
503
504    /**
505     * Does the UML Element contain the named Keyword? Keywords can be separated by space, comma,
506     * pipe, semicolon, or << >>
507     * @see ModelElementFacade#hasKeyword(String keywordName)
508     */
509    public boolean hasKeyword(String keywordName)
510    {
511        return this.getSuperServiceOperation().hasKeyword(keywordName);
512    }
513
514    /**
515     * Returns true if the model element has the specified stereotype.  If the stereotype itself
516     * does not match, then a search will be made up the stereotype inheritance hierarchy, and if
517     * one of the stereotype's ancestors has a matching name this method will return true, false
518     * otherwise.
519     * For example, if we have a certain stereotype called <<exception>> and a model element has a
520     * stereotype called <<applicationException>> which extends <<exception>>, when calling this
521     * method with 'stereotypeName' defined as 'exception' the method would return true since
522     * <<applicationException>> inherits from <<exception>>.  If you want to check if the model
523     * element has the exact stereotype, then use the method 'hasExactStereotype' instead.
524     * @see ModelElementFacade#hasStereotype(String stereotypeName)
525     */
526    public boolean hasStereotype(String stereotypeName)
527    {
528        return this.getSuperServiceOperation().hasStereotype(stereotypeName);
529    }
530
531    /**
532     * True if there are target dependencies from this element that are instances of BindingFacade.
533     * Deprecated in UML2: Use TemplateBinding parameters instead of dependencies.
534     * @see ModelElementFacade#isBindingDependenciesPresent()
535     */
536    public boolean isBindingDependenciesPresent()
537    {
538        return this.getSuperServiceOperation().isBindingDependenciesPresent();
539    }
540
541    /**
542     * Indicates if any constraints are present on this model element.
543     * @see ModelElementFacade#isConstraintsPresent()
544     */
545    public boolean isConstraintsPresent()
546    {
547        return this.getSuperServiceOperation().isConstraintsPresent();
548    }
549
550    /**
551     * Indicates if any documentation is present on this model element.
552     * @see ModelElementFacade#isDocumentationPresent()
553     */
554    public boolean isDocumentationPresent()
555    {
556        return this.getSuperServiceOperation().isDocumentationPresent();
557    }
558
559    /**
560     * True if this element name is a reserved word in Java, C#, ANSI or ISO C, C++, JavaScript.
561     * @see ModelElementFacade#isReservedWord()
562     */
563    public boolean isReservedWord()
564    {
565        return this.getSuperServiceOperation().isReservedWord();
566    }
567
568    /**
569     * True is there are template parameters on this model element. For UML2, applies to Class,
570     * Operation, Property, and Parameter.
571     * @see ModelElementFacade#isTemplateParametersPresent()
572     */
573    public boolean isTemplateParametersPresent()
574    {
575        return this.getSuperServiceOperation().isTemplateParametersPresent();
576    }
577
578    /**
579     * True if this element name is a valid identifier name in Java, C#, ANSI or ISO C, C++,
580     * JavaScript. Contains no spaces, special characters etc. Constraint always applied on
581     * Enumerations and Interfaces, optionally applies on other model elements.
582     * @see ModelElementFacade#isValidIdentifierName()
583     */
584    public boolean isValidIdentifierName()
585    {
586        return this.getSuperServiceOperation().isValidIdentifierName();
587    }
588
589    /**
590     * Searches for the constraint with the specified 'name' on this model element, and if found
591     * translates it using the specified 'translation' from a translation library discovered by the
592     * framework.
593     * @see ModelElementFacade#translateConstraint(String name, String translation)
594     */
595    public String translateConstraint(String name, String translation)
596    {
597        return this.getSuperServiceOperation().translateConstraint(name, translation);
598    }
599
600    /**
601     * Translates all constraints belonging to this model element with the given 'translation'.
602     * @see ModelElementFacade#translateConstraints(String translation)
603     */
604    public String[] translateConstraints(String translation)
605    {
606        return this.getSuperServiceOperation().translateConstraints(translation);
607    }
608
609    /**
610     * Translates the constraints of the specified 'kind' belonging to this model element.
611     * @see ModelElementFacade#translateConstraints(String kind, String translation)
612     */
613    public String[] translateConstraints(String kind, String translation)
614    {
615        return this.getSuperServiceOperation().translateConstraints(kind, translation);
616    }
617
618    /**
619     * Finds the parameter on this operation having the given name, if no parameter is found, null
620     * is returned instead.
621     * @see OperationFacade#findParameter(String name)
622     */
623    public ParameterFacade findParameter(String name)
624    {
625        return this.getSuperServiceOperation().findParameter(name);
626    }
627
628    /**
629     * Searches the given feature for the specified tag.
630     * If the follow boolean is set to true then the search will continue from the class operation
631     * to the class itself and then up the class hierarchy.
632     * @see OperationFacade#findTaggedValue(String name, boolean follow)
633     */
634    public Object findTaggedValue(String name, boolean follow)
635    {
636        return this.getSuperServiceOperation().findTaggedValue(name, follow);
637    }
638
639    /**
640     * A comma separated list of all argument names.
641     * @see OperationFacade#getArgumentNames()
642     */
643    public String getArgumentNames()
644    {
645        return this.getSuperServiceOperation().getArgumentNames();
646    }
647
648    /**
649     * A comma separated list of all types of each argument, in order.
650     * @see OperationFacade#getArgumentTypeNames()
651     */
652    public String getArgumentTypeNames()
653    {
654        return this.getSuperServiceOperation().getArgumentTypeNames();
655    }
656
657    /**
658     * Specification of an argument used to pass information into or out of an invocation of a
659     * behavioral
660     * feature. Parameters are allowed to be treated as connectable elements. Parameters have
661     * support for
662     * streaming, exceptions, and parameter sets.
663     * @see OperationFacade#getArguments()
664     */
665    public Collection<ParameterFacade> getArguments()
666    {
667        return this.getSuperServiceOperation().getArguments();
668    }
669
670    /**
671     * Constructs the operation call with the operation name
672     * @see OperationFacade#getCall()
673     */
674    public String getCall()
675    {
676        return this.getSuperServiceOperation().getCall();
677    }
678
679    /**
680     * Returns the concurrency modifier for this operation (i.e. concurrent, guarded or sequential)
681     * of the model element, will attempt a lookup for these values in the language mappings (if
682     * any).
683     * @see OperationFacade#getConcurrency()
684     */
685    public String getConcurrency()
686    {
687        return this.getSuperServiceOperation().getConcurrency();
688    }
689
690    /**
691     * A comma separated list containing all exceptions that this operation throws.  Exceptions are
692     * determined through dependencies that have the target element stereotyped as <<Exception>>.
693     * @see OperationFacade#getExceptionList()
694     */
695    public String getExceptionList()
696    {
697        return this.getSuperServiceOperation().getExceptionList();
698    }
699
700    /**
701     * Returns a comma separated list of exceptions appended to the comma separated list of fully
702     * qualified 'initialException' classes passed in to this method.
703     * @see OperationFacade#getExceptionList(String initialExceptions)
704     */
705    public String getExceptionList(String initialExceptions)
706    {
707        return this.getSuperServiceOperation().getExceptionList(initialExceptions);
708    }
709
710    /**
711     * A collection of all exceptions thrown by this operation.
712     * @see OperationFacade#getExceptions()
713     */
714    public Collection<ModelElementFacade> getExceptions()
715    {
716        return this.getSuperServiceOperation().getExceptions();
717    }
718
719    /**
720     * Return Type with multiplicity taken into account. UML14 does not allow multiplicity *.
721     * @see OperationFacade#getGetterSetterReturnTypeName()
722     */
723    public String getGetterSetterReturnTypeName()
724    {
725        return this.getSuperServiceOperation().getGetterSetterReturnTypeName();
726    }
727
728    /**
729     * the lower value for the multiplicity
730     * -only applicable for UML2
731     * @see OperationFacade#getLower()
732     */
733    public int getLower()
734    {
735        return this.getSuperServiceOperation().getLower();
736    }
737
738    /**
739     * Returns the operation method body determined from UML sequence diagrams or other UML sources.
740     * @see OperationFacade#getMethodBody()
741     */
742    public String getMethodBody()
743    {
744        return this.getSuperServiceOperation().getMethodBody();
745    }
746
747    /**
748     * The operation this operation overrides, null if this operation is not overriding.
749     * @see OperationFacade#getOverriddenOperation()
750     */
751    public OperationFacade getOverriddenOperation()
752    {
753        return this.getSuperServiceOperation().getOverriddenOperation();
754    }
755
756    /**
757     * Gets the owner of this operation
758     * @see OperationFacade#getOwner()
759     */
760    public ClassifierFacade getOwner()
761    {
762        return this.getSuperServiceOperation().getOwner();
763    }
764
765    /**
766     * Return all parameters for the operation, including the return parameter.
767     * @see OperationFacade#getParameters()
768     */
769    public Collection<ParameterFacade> getParameters()
770    {
771        return this.getSuperServiceOperation().getParameters();
772    }
773
774    /**
775     * The name of the operation that handles postcondition constraints.
776     * @see OperationFacade#getPostconditionName()
777     */
778    public String getPostconditionName()
779    {
780        return this.getSuperServiceOperation().getPostconditionName();
781    }
782
783    /**
784     * The postcondition constraints belonging to this operation.
785     * @see OperationFacade#getPostconditions()
786     */
787    public Collection<ConstraintFacade> getPostconditions()
788    {
789        return this.getSuperServiceOperation().getPostconditions();
790    }
791
792    /**
793     * The call to the precondition operation.
794     * @see OperationFacade#getPreconditionCall()
795     */
796    public String getPreconditionCall()
797    {
798        return this.getSuperServiceOperation().getPreconditionCall();
799    }
800
801    /**
802     * The name of the operation that handles precondition constraints.
803     * @see OperationFacade#getPreconditionName()
804     */
805    public String getPreconditionName()
806    {
807        return this.getSuperServiceOperation().getPreconditionName();
808    }
809
810    /**
811     * The signature of the precondition operation.
812     * @see OperationFacade#getPreconditionSignature()
813     */
814    public String getPreconditionSignature()
815    {
816        return this.getSuperServiceOperation().getPreconditionSignature();
817    }
818
819    /**
820     * The precondition constraints belonging to this operation.
821     * @see OperationFacade#getPreconditions()
822     */
823    public Collection<ConstraintFacade> getPreconditions()
824    {
825        return this.getSuperServiceOperation().getPreconditions();
826    }
827
828    /**
829     * (UML2 Only). Get the actual return parameter (which may have stereotypes etc).
830     * @see OperationFacade#getReturnParameter()
831     */
832    public ParameterFacade getReturnParameter()
833    {
834        return this.getSuperServiceOperation().getReturnParameter();
835    }
836
837    /**
838     * The operation return type parameter.
839     * @see OperationFacade#getReturnType()
840     */
841    public ClassifierFacade getReturnType()
842    {
843        return this.getSuperServiceOperation().getReturnType();
844    }
845
846    /**
847     * Return the operation signature, including public/protested abstract returnType name plus
848     * argument type and name
849     * @see OperationFacade#getSignature()
850     */
851    public String getSignature()
852    {
853        return this.getSuperServiceOperation().getSignature();
854    }
855
856    /**
857     * Returns the signature of the operation and optionally appends the argument names (if
858     * withArgumentNames is true), otherwise returns the signature with just the types alone in the
859     * signature.
860     * @see OperationFacade#getSignature(boolean withArgumentNames)
861     */
862    public String getSignature(boolean withArgumentNames)
863    {
864        return this.getSuperServiceOperation().getSignature(withArgumentNames);
865    }
866
867    /**
868     * Returns the signature of the operation and optionally appends the given 'argumentModifier' to
869     * each argument.
870     * @see OperationFacade#getSignature(String argumentModifier)
871     */
872    public String getSignature(String argumentModifier)
873    {
874        return this.getSuperServiceOperation().getSignature(argumentModifier);
875    }
876
877    /**
878     * A comma-separated parameter list  (type and name of each parameter) of an operation.
879     * @see OperationFacade#getTypedArgumentList()
880     */
881    public String getTypedArgumentList()
882    {
883        return this.getSuperServiceOperation().getTypedArgumentList();
884    }
885
886    /**
887     * A comma-separated parameter list  (type and name of each parameter) of an operation with an
888     * optional modifier (i.e final) before each parameter.
889     * @see OperationFacade#getTypedArgumentList(String modifier)
890     */
891    public String getTypedArgumentList(String modifier)
892    {
893        return this.getSuperServiceOperation().getTypedArgumentList(modifier);
894    }
895
896    /**
897     * the upper value for the multiplicity (will be -1 for *)
898     * - only applicable for UML2
899     * @see OperationFacade#getUpper()
900     */
901    public int getUpper()
902    {
903        return this.getSuperServiceOperation().getUpper();
904    }
905
906    /**
907     * True is the operation is abstract.
908     * @see OperationFacade#isAbstract()
909     */
910    public boolean isAbstract()
911    {
912        return this.getSuperServiceOperation().isAbstract();
913    }
914
915    /**
916     * True if the operation has (i.e. throws any exceptions) false otherwise.
917     * @see OperationFacade#isExceptionsPresent()
918     */
919    public boolean isExceptionsPresent()
920    {
921        return this.getSuperServiceOperation().isExceptionsPresent();
922    }
923
924    /**
925     * IsLeaf property in the operation. If true, operation is final, cannot be extended or
926     * implemented by a descendant. Default=false.
927     * @see OperationFacade#isLeaf()
928     */
929    public boolean isLeaf()
930    {
931        return this.getSuperServiceOperation().isLeaf();
932    }
933
934    /**
935     * UML2 only. If the return type parameter multiplicity>1 OR the operation multiplicity>1.
936     * Default=false.
937     * @see OperationFacade#isMany()
938     */
939    public boolean isMany()
940    {
941        return this.getSuperServiceOperation().isMany();
942    }
943
944    /**
945     * UML2 only: If isMany (Collection type returned), is the type unique within the collection. 
946     * Unique+Ordered determines CollectionType implementation of return result. Default=false.
947     * @see OperationFacade#isOrdered()
948     */
949    public boolean isOrdered()
950    {
951        return this.getSuperServiceOperation().isOrdered();
952    }
953
954    /**
955     * True if this operation overrides an operation defined in an ancestor class. An operation
956     * overrides when the names of the operations as well as the types of the arguments are equal.
957     * The return type may be different and is, as well as any exceptions, ignored.
958     * @see OperationFacade#isOverriding()
959     */
960    public boolean isOverriding()
961    {
962        return this.getSuperServiceOperation().isOverriding();
963    }
964
965    /**
966     * Whether any postcondition constraints are present on this operation.
967     * @see OperationFacade#isPostconditionsPresent()
968     */
969    public boolean isPostconditionsPresent()
970    {
971        return this.getSuperServiceOperation().isPostconditionsPresent();
972    }
973
974    /**
975     * Whether any precondition constraints are present on this operation.
976     * @see OperationFacade#isPreconditionsPresent()
977     */
978    public boolean isPreconditionsPresent()
979    {
980        return this.getSuperServiceOperation().isPreconditionsPresent();
981    }
982
983    /**
984     * Indicates whether or not this operation is a query operation.
985     * @see OperationFacade#isQuery()
986     */
987    public boolean isQuery()
988    {
989        return this.getSuperServiceOperation().isQuery();
990    }
991
992    /**
993     * True/false depending on whether or not the operation has a return type or not (i.e. a return
994     * type of something other than void).
995     * @see OperationFacade#isReturnTypePresent()
996     */
997    public boolean isReturnTypePresent()
998    {
999        return this.getSuperServiceOperation().isReturnTypePresent();
1000    }
1001
1002    /**
1003     * True is the operation is static (only a single instance can be instantiated).
1004     * @see OperationFacade#isStatic()
1005     */
1006    public boolean isStatic()
1007    {
1008        return this.getSuperServiceOperation().isStatic();
1009    }
1010
1011    /**
1012     * UML2 only: for Collection return type, is the type unique within the collection.
1013     * Unique+Ordered determines the returned CollectionType. Default=false.
1014     * @see OperationFacade#isUnique()
1015     */
1016    public boolean isUnique()
1017    {
1018        return this.getSuperServiceOperation().isUnique();
1019    }
1020
1021    /**
1022     * The destination for any incoming messages.
1023     * @see ServiceOperation#getIncomingDestination()
1024     */
1025    public Destination getIncomingDestination()
1026    {
1027        return this.getSuperServiceOperation().getIncomingDestination();
1028    }
1029
1030    /**
1031     * The destination for any outgoing messages.
1032     * @see ServiceOperation#getOutgoingDestination()
1033     */
1034    public Destination getOutgoingDestination()
1035    {
1036        return this.getSuperServiceOperation().getOutgoingDestination();
1037    }
1038
1039    /**
1040     * The users of the service operation, these are the actor's that can access this operation.
1041     * @see ServiceOperation#getRoles()
1042     */
1043    public Collection<Role> getRoles()
1044    {
1045        return this.getSuperServiceOperation().getRoles();
1046    }
1047
1048    /**
1049     * The service which owns the service operation.
1050     * @see ServiceOperation#getService()
1051     */
1052    public Service getService()
1053    {
1054        return this.getSuperServiceOperation().getService();
1055    }
1056
1057    /**
1058     * Whether or not this operation represents an "incoming" message operation (i.e. it receives
1059     * messages from Queues or Topics).
1060     * @see ServiceOperation#isIncomingMessageOperation()
1061     */
1062    public boolean isIncomingMessageOperation()
1063    {
1064        return this.getSuperServiceOperation().isIncomingMessageOperation();
1065    }
1066
1067    /**
1068     * Whether or not this is operation accepts incoming or outgoing messages.
1069     * @see ServiceOperation#isMessageOperation()
1070     */
1071    public boolean isMessageOperation()
1072    {
1073        return this.getSuperServiceOperation().isMessageOperation();
1074    }
1075
1076    /**
1077     * Whether or not this service operation represents an "outgoing" messaging operation (i.e. it
1078     * sends messages to Queues or Topics).
1079     * @see ServiceOperation#isOutgoingMessageOperation()
1080     */
1081    public boolean isOutgoingMessageOperation()
1082    {
1083        return this.getSuperServiceOperation().isOutgoingMessageOperation();
1084    }
1085
1086    /**
1087     * @see org.andromda.core.metafacade.MetafacadeBase#initialize()
1088     */
1089    @Override
1090    public void initialize()
1091    {
1092        this.getSuperServiceOperation().initialize();
1093    }
1094
1095    /**
1096     * @return Object getSuperServiceOperation().getValidationOwner()
1097     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationOwner()
1098     */
1099    @Override
1100    public Object getValidationOwner()
1101    {
1102        Object owner = this.getSuperServiceOperation().getValidationOwner();
1103        return owner;
1104    }
1105
1106    /**
1107     * @return String getSuperServiceOperation().getValidationName()
1108     * @see org.andromda.core.metafacade.MetafacadeBase#getValidationName()
1109     */
1110    @Override
1111    public String getValidationName()
1112    {
1113        String name = this.getSuperServiceOperation().getValidationName();
1114        return name;
1115    }
1116
1117    /**
1118     * @param validationMessages Collection<ModelValidationMessage>
1119     * @see org.andromda.core.metafacade.MetafacadeBase#validateInvariants(Collection validationMessages)
1120     */
1121    @Override
1122    public void validateInvariants(Collection<ModelValidationMessage> validationMessages)
1123    {
1124        this.getSuperServiceOperation().validateInvariants(validationMessages);
1125    }
1126
1127    /**
1128     * The property that stores the name of the metafacade.
1129     */
1130    private static final String NAME_PROPERTY = "name";
1131    private static final String FQNAME_PROPERTY = "fullyQualifiedName";
1132
1133    /**
1134     * @see Object#toString()
1135     */
1136    @Override
1137    public String toString()
1138    {
1139        final StringBuilder toString = new StringBuilder(this.getClass().getName());
1140        toString.append("[");
1141        try
1142        {
1143            toString.append(Introspector.instance().getProperty(this, FQNAME_PROPERTY));
1144        }
1145        catch (final Throwable tryAgain)
1146        {
1147            try
1148            {
1149                toString.append(Introspector.instance().getProperty(this, NAME_PROPERTY));
1150            }
1151            catch (final Throwable ignore)
1152            {
1153                // - just ignore when the metafacade doesn't have a name or fullyQualifiedName property
1154            }
1155        }
1156        toString.append("]");
1157        return toString.toString();
1158    }
1159}