001// license-header java merge-point
002//
003// Attention: generated code (by Metafacade.vsl) - do not modify!
004//
005package org.andromda.cartridges.meta.metafacades;
006
007import java.util.Collection;
008import org.andromda.metafacades.uml.ClassifierFacade;
009
010/**
011 * Facade for use in the andromda-meta cartridge. It hides a Classifier that represents a
012 * <<metafacade>> object.
013 *
014 * Metafacade interface to be used by AndroMDA cartridges.
015 */
016public interface Metafacade
017    extends ClassifierFacade
018{
019    /**
020     * Indicates the metafacade type (used for metafacade mappings).
021     *
022     * @return boolean always <code>true</code>
023     */
024    public boolean isMetafacadeMetaType();
025
026    /**
027     * All generalization links (including all parents)
028     * @return Collection<Metafacade>
029     */
030    public Collection<Metafacade> getAllParents();
031
032    /**
033     * The fully qualified name for the implementation of the metafacade.
034     * @return String
035     */
036    public String getFullyQualifiedLogicImplName();
037
038    /**
039     * The fully qualified name for the metafacade "Logic" class.
040     * @return String
041     */
042    public String getFullyQualifiedLogicName();
043
044    /**
045     * The number of parents this metafacade has.
046     * @return int
047     */
048    public int getGeneralizationCount();
049
050    /**
051     * The 'Logic' file location.
052     * @return String
053     */
054    public String getLogicFile();
055
056    /**
057     * The 'Logic' implementation file location.
058     * @return String
059     */
060    public String getLogicImplFile();
061
062    /**
063     * The name of the 'Logic' implementation name.
064     * @return String
065     */
066    public String getLogicImplName();
067
068    /**
069     * The name of the metafacade 'Logic' class.
070     * @return String
071     */
072    public String getLogicName();
073
074    /**
075     * The package name to which the 'Logic' metafacade classes are generated.
076     * @return String
077     */
078    public String getLogicPackageName();
079
080    /**
081     * A Classifier is a classification of instances - it describes a set of instances that have
082     * features
083     * in common. Can specify a generalization hierarchy by referencing its general classifiers. It
084     * may be
085     * a Class, DataType, PrimitiveType, Association, Collaboration, UseCase, etc. Can specify a
086     * generalization hierarchy by referencing its general classifiers. Has the capability to own
087     * collaboration uses. These collaboration uses link a collaboration with the classifier to give
088     * a
089     * description of the workings of the classifier. Classifier is defined to be a kind of
090     * templateable
091     * element so that a classifier can be parameterized. It is also defined to be a kind of
092     * parameterable
093     * element so that a classifier can be a formal template parameter.
094     * @return ClassifierFacade
095     */
096    public ClassifierFacade getMetaclass();
097
098    /**
099     * Gets all method information as a collection of MethodData instances for the metafacade.
100     * @return Collection
101     */
102    public Collection getMethodDataForPSM();
103
104    /**
105     * Gets all inherited method information as a collection of MethodData instances for the given
106     * superMetafacade.
107     * @param superMetafacade ClassifierFacade
108     * @return Collection
109     */
110    public Collection getMethodDataForPSM(ClassifierFacade superMetafacade);
111
112    /**
113     * Indicates if the meta class construct argument requires a cast to the super metafacade's
114     * metaclass.
115     * @return boolean
116     */
117    public boolean isConstructorRequiresMetaclassCast();
118
119    /**
120     * True/false depending on whether or not this class's metaclass is a direct dependency (true)
121     * or an inherited dependency (false).
122     * @return boolean
123     */
124    public boolean isMetaclassDirectDependency();
125
126    /**
127     * Indicates if the metafacade requires a delegate for inheritance instead of actual
128     * inheritance.  This is true, when the metafacade is inheriting from a metafacade from a
129     * different package (since that means it will most likely be a cartridge metafacade inheriting
130     * from a set of shared metafacades for a meta model).
131     * @return boolean
132     */
133    public boolean isRequiresInheritanceDelegatation();
134}