StandardProfile

java.lang.Object
- com.nomagic.magicdraw.utils.StandardObjectHolder
- - com.nomagic.uml2.ext.jmi.helpers.StereotypeByProfileCache
  - - com.nomagic.uml2.StandardProfile

All Implemented Interfaces:

java.beans.PropertyChangeListener, java.util.EventListener
```
@OpenApiAll
public class StandardProfile
extends StereotypeByProfileCache
```

Nested Class Summary
- Nested classes/interfaces inherited from class com.nomagic.uml2.ext.jmi.helpers.StereotypeByProfileCache
  StereotypeByProfileCache.AbstractStereotypeWrapper, StereotypeByProfileCache.IsTypeOfCache

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`AUXILIARY_STEREOTYPE`
`static java.lang.String`	`BUILDCOMPONENT_STEREOTYPE`
`static java.lang.String`	`CALL_STEREOTYPE`
`static java.lang.String`	`CREATE_STEREOTYPE`
`static java.lang.String`	`DERIVE_STEREOTYPE`
`static java.lang.String`	`DESTROY_STEREOTYPE`
`static java.lang.String`	`DOCUMENT_STEREOTYPE`
`static java.lang.String`	`ENTITY_STEREOTYPE`
`static java.lang.String`	`EXECUTABLE_STEREOTYPE`
`static java.lang.String`	`FILE_STEREOTYPE`
`static java.lang.String`	`FOCUS_STEREOTYPE`
`static java.lang.String`	`FRAMEWORK_STEREOTYPE`
`static java.lang.String`	`IMPLEMENT_STEREOTYPE`
`static java.lang.String`	`IMPLEMENTATIONCLASS_STEREOTYPE`
`static java.lang.String`	`INSTANTIATE_STEREOTYPE`
`static java.lang.String`	`LIBRARY_STEREOTYPE`
`static java.lang.String`	`METACLASS_STEREOTYPE`
`static java.lang.String`	`METAMODEL_STEREOTYPE`
`static java.lang.String`	`MODELLIBRARY_STEREOTYPE`
`static java.lang.String`	`PROCESS_STEREOTYPE`
`static java.lang.String`	`PROFILE_NAME`
`static java.lang.String`	`PROFILE_URI`
`static java.lang.String`	`REALIZATION_STEREOTYPE`
`static java.lang.String`	`REFINE_STEREOTYPE`
`static java.lang.String`	`RESPONSIBILITY_STEREOTYPE`
`static java.lang.String`	`SCRIPT_STEREOTYPE`
`static java.lang.String`	`SEND_STEREOTYPE`
`static java.lang.String`	`SERVICE_STEREOTYPE`
`static java.lang.String`	`SOURCE_STEREOTYPE`
`static java.lang.String`	`SPECIFICATION_STEREOTYPE`
`static java.lang.String`	`SUBSYSTEM_STEREOTYPE`
`static java.lang.String`	`SYSTEMMODEL_STEREOTYPE`
`static java.lang.String`	`TRACE_STEREOTYPE`
`static java.lang.String`	`TYPE_STEREOTYPE`
`static java.lang.String`	`UTILITY_STEREOTYPE`

Constructor Summary

Constructors
Constructor and Description

StandardProfile(Project prj)

Constructors
Constructor and Description
`StandardProfile(Project prj)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected java.util.Collection<Stereotype>`	`generatedGetAllStereotypes()` Generated method for getting all stereotypes contained within this profile.
`Stereotype`	`getAuxiliary()` A class that supports another more central or fundamental class, typically by implementing secondary logic or control flow.
`Stereotype`	`getBuildComponent()` A collection of elements defined for the purpose of system level development activities, such as compilation and versioning.
`Stereotype`	`getCall()` A usage dependency whose source is an operation and whose target is an operation.
`Stereotype`	`getCreate()` A usage dependency denoting that the client classifier creates instances of the supplier classifier.
`Stereotype`	`getDerive()` Specifies a derivation relationship among model elements that are usually, but not necessarily, of the same type.
`Stereotype`	`getDestroy()` Specifies that the designated feature destroys an instance of the classifier to which the feature is attached.
`Stereotype`	`getDocument()` A generic file that is not a source file or executable .
`Stereotype`	`getEntity()` A persistent information component representing a business concept.
`Stereotype`	`getExecutable()` Denotes a program that may be run on a node.
`Stereotype`	`getFile()` A physical file in the context of the system developed.
`Stereotype`	`getFocus()` A class that defines the core logic or control flow for one or more auxiliary classes that support it.
`Stereotype`	`getFramework()` A package that contains model elements which specify a reusable architecture for all or part of a system.
`Stereotype`	`getImplement()` A component definition that is not intended to have a specification itself.
`Stereotype`	`getImplementationClass()` The implementation of a class in some programming language (e.g., C++, Smalltalk, Java) in which an instance may not have more than one class.
`static StandardProfile`	`getInstance(BaseElement element)`
`static StandardProfile`	`getInstance(Project prj)`
`Stereotype`	`getInstantiate()` A usage dependency among classifiers indicating that operations on the client create instances of the supplier.
`Stereotype`	`getLibrary()` Denotes a static or dynamic library.
`Stereotype`	`getMetaclass()`
`Stereotype`	`getMetamodel()` A model of a model, that typically contains metaclasses.
`Stereotype`	`getModelLibrary()` A package that contains model elements which are intended to be reused by other packages.
`Stereotype`	`getProcess()` A transaction based component.
`Stereotype`	`getRealization()` A classifier that specifies a domain of objects and that also defines the physical implementation of those objects.
`Stereotype`	`getRefine()` Specifies a refinement relationship between model elements at different semantic levels, such as analysis and design.
`Stereotype`	`getResponsibility()` A contract or an obligation of an element in its relationship to other elements.
`Stereotype`	`getScript()` A script file that can be interpreted by a computer system.
`Stereotype`	`getSend()` A usage dependency whose source is an operation and whose target is a signal, specifying that the source sends the target signal.
`Stereotype`	`getService()` A stateless, functional component (computes a value).
`Stereotype`	`getSource()` Denotes a source file that can be compiled into an executable file.Subclass of <>.
`Stereotype`	`getSpecification()` A classifier that specifies a domain of objects without defining the physical implementation of those objects.
`Stereotype`	`getSubsystem()` A unit of hierarchical decomposition for large systems.
`Stereotype`	`getSystemModel()` A systemModel is a stereotyped model that contains a collection of models of the same physical system.
`Stereotype`	`getTrace()` Specifies a trace relationship between model elements or sets of model elements that represent the same concept in different models.
`Stereotype`	`getType()` A class that specifies a domain of objects together with the operations applicable to the objects, without defining the physical implementation of those objects.
`Stereotype`	`getUtility()` A class that has no instances, but rather denotes a named collection of non-member attributes and operations, all of which are class-scoped.
`static boolean`	`isAuxiliary(Element element)`
`static boolean`	`isBuildComponent(Element element)`
`static boolean`	`isCall(Element element)`
`static boolean`	`isCreate(Element element)`
`static boolean`	`isDerive(Element element)`
`static boolean`	`isDestroy(Element element)`
`static boolean`	`isDocument(Element element)`
`static boolean`	`isEntity(Element element)`
`static boolean`	`isExecutable(Element element)`
`static boolean`	`isFile(Element element)`
`static boolean`	`isFocus(Element element)`
`static boolean`	`isFramework(Element element)`
`static boolean`	`isImplement(Element element)`
`static boolean`	`isImplementationClass(Element element)`
`static boolean`	`isInstantiate(Element element)`
`static boolean`	`isLibrary(Element element)`
`static boolean`	`isMetaclass(Element element)`
`static boolean`	`isMetamodel(Element element)`
`static boolean`	`isModelLibrary(Element element)`
`static boolean`	`isProcess(Element element)`
`static boolean`	`isRealization(Element element)`
`static boolean`	`isRefine(Element element)`
`static boolean`	`isResponsibility(Element element)`
`static boolean`	`isScript(Element element)`
`static boolean`	`isSend(Element element)`
`static boolean`	`isService(Element element)`
`static boolean`	`isSource(Element element)`
`static boolean`	`isSpecification(Element element)`
`static boolean`	`isSubsystem(Element element)`
`static boolean`	`isSystemModel(Element element)`
`static boolean`	`isTrace(Element element)`
`static boolean`	`isType(Element element)`
`static boolean`	`isUtility(Element element)`

Methods inherited from class com.nomagic.uml2.ext.jmi.helpers.StereotypeByProfileCache
clearCach, getAllStereotypes, getDataType, getProfile, getStereotype, getStereotype, isTypeOf, isTypeOf, propertyChange

Methods inherited from class com.nomagic.magicdraw.utils.StandardObjectHolder
_getInstance, _getInstances, getReferencedProject, registerInstance, resetAllCachedObjects, resetCachedObjects

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PROFILE_URI
```
public static final java.lang.String PROFILE_URI
```
    See Also:
    Constant Field Values
  - PROFILE_NAME
```
public static final java.lang.String PROFILE_NAME
```
    See Also:
    Constant Field Values
  - AUXILIARY_STEREOTYPE
```
public static final java.lang.String AUXILIARY_STEREOTYPE
```
    See Also:
    Constant Field Values
  - BUILDCOMPONENT_STEREOTYPE
```
public static final java.lang.String BUILDCOMPONENT_STEREOTYPE
```
    See Also:
    Constant Field Values
  - CALL_STEREOTYPE
```
public static final java.lang.String CALL_STEREOTYPE
```
    See Also:
    Constant Field Values
  - CREATE_STEREOTYPE
```
public static final java.lang.String CREATE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - DERIVE_STEREOTYPE
```
public static final java.lang.String DERIVE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - DESTROY_STEREOTYPE
```
public static final java.lang.String DESTROY_STEREOTYPE
```
    See Also:
    Constant Field Values
  - DOCUMENT_STEREOTYPE
```
public static final java.lang.String DOCUMENT_STEREOTYPE
```
    See Also:
    Constant Field Values
  - ENTITY_STEREOTYPE
```
public static final java.lang.String ENTITY_STEREOTYPE
```
    See Also:
    Constant Field Values
  - EXECUTABLE_STEREOTYPE
```
public static final java.lang.String EXECUTABLE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - FILE_STEREOTYPE
```
public static final java.lang.String FILE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - FOCUS_STEREOTYPE
```
public static final java.lang.String FOCUS_STEREOTYPE
```
    See Also:
    Constant Field Values
  - FRAMEWORK_STEREOTYPE
```
public static final java.lang.String FRAMEWORK_STEREOTYPE
```
    See Also:
    Constant Field Values
  - IMPLEMENT_STEREOTYPE
```
public static final java.lang.String IMPLEMENT_STEREOTYPE
```
    See Also:
    Constant Field Values
  - IMPLEMENTATIONCLASS_STEREOTYPE
```
public static final java.lang.String IMPLEMENTATIONCLASS_STEREOTYPE
```
    See Also:
    Constant Field Values
  - INSTANTIATE_STEREOTYPE
```
public static final java.lang.String INSTANTIATE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - LIBRARY_STEREOTYPE
```
public static final java.lang.String LIBRARY_STEREOTYPE
```
    See Also:
    Constant Field Values
  - METACLASS_STEREOTYPE
```
public static final java.lang.String METACLASS_STEREOTYPE
```
    See Also:
    Constant Field Values
  - METAMODEL_STEREOTYPE
```
public static final java.lang.String METAMODEL_STEREOTYPE
```
    See Also:
    Constant Field Values
  - MODELLIBRARY_STEREOTYPE
```
public static final java.lang.String MODELLIBRARY_STEREOTYPE
```
    See Also:
    Constant Field Values
  - PROCESS_STEREOTYPE
```
public static final java.lang.String PROCESS_STEREOTYPE
```
    See Also:
    Constant Field Values
  - REALIZATION_STEREOTYPE
```
public static final java.lang.String REALIZATION_STEREOTYPE
```
    See Also:
    Constant Field Values
  - REFINE_STEREOTYPE
```
public static final java.lang.String REFINE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - RESPONSIBILITY_STEREOTYPE
```
public static final java.lang.String RESPONSIBILITY_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SCRIPT_STEREOTYPE
```
public static final java.lang.String SCRIPT_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SEND_STEREOTYPE
```
public static final java.lang.String SEND_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SERVICE_STEREOTYPE
```
public static final java.lang.String SERVICE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SOURCE_STEREOTYPE
```
public static final java.lang.String SOURCE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SPECIFICATION_STEREOTYPE
```
public static final java.lang.String SPECIFICATION_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SUBSYSTEM_STEREOTYPE
```
public static final java.lang.String SUBSYSTEM_STEREOTYPE
```
    See Also:
    Constant Field Values
  - SYSTEMMODEL_STEREOTYPE
```
public static final java.lang.String SYSTEMMODEL_STEREOTYPE
```
    See Also:
    Constant Field Values
  - TRACE_STEREOTYPE
```
public static final java.lang.String TRACE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - TYPE_STEREOTYPE
```
public static final java.lang.String TYPE_STEREOTYPE
```
    See Also:
    Constant Field Values
  - UTILITY_STEREOTYPE
```
public static final java.lang.String UTILITY_STEREOTYPE
```
    See Also:
    Constant Field Values
- Constructor Detail
  - StandardProfile
```
public StandardProfile(@Nonnull
               Project prj)
```
- Method Detail
  - getInstance
```
public static StandardProfile getInstance(@Nonnull
                          BaseElement element)
```
  - getInstance
```
public static StandardProfile getInstance(@Nonnull
                          Project prj)
```
  - getAuxiliary
```
public Stereotype getAuxiliary()
```
    A class that supports another more central or fundamental class, typically by implementing secondary logic or control flow. The class that the auxiliary supports may be defined explicitly using a Focus class or implicitly by a dependency relationship. Auxiliary classes are typically used together with Focus classes, and are particularly useful for specifying the secondary business logic or control flow of components during design. See also: focus .
    
    Returns:
    stereotype
  - getBuildComponent
```
public Stereotype getBuildComponent()
```
    A collection of elements defined for the purpose of system level development activities, such as compilation and versioning.
    
    Returns:
    stereotype
  - getCall
```
public Stereotype getCall()
```
    A usage dependency whose source is an operation and whose target is an operation. The relationship may also be subsumed to the class containing an operation, with the meaning that there exists an operation in the class to which the dependency applies. A call dependency specifies that the source operation or an operation in the source class invokes the target operation or an operation in the target class. A call dependency may connect a source operation to any target operation that is within scope including, but not limited to, operations of the enclosing classifier and operations of other visible classifiers.
    
    Returns:
    stereotype
  - getCreate
```
public Stereotype getCreate()
```
    A usage dependency denoting that the client classifier creates instances of the supplier classifier. Specifies that the designated feature creates an instance of the classifier to which the feature is attached. May be promoted to the Classifier containing the feature.
    
    Returns:
    stereotype
  - getDerive
```
public Stereotype getDerive()
```
    Specifies a derivation relationship among model elements that are usually, but not necessarily, of the same type. A derived dependency specifies that the client may be computed from the supplier. The mapping specifies the computation. The client may be implemented for design reasons, such as efficiency, even though it is logically redundant.
    
    Returns:
    stereotype
  - getDestroy
```
public Stereotype getDestroy()
```
    Specifies that the designated feature destroys an instance of the classifier to which the feature is attached. May be promoted to the classifier containing the feature.
    
    Returns:
    stereotype
  - getDocument
```
public Stereotype getDocument()
```
    A generic file that is not a source file or executable . Subclass of file .
    
    Returns:
    stereotype
  - getEntity
```
public Stereotype getEntity()
```
    A persistent information component representing a business concept.
    
    Returns:
    stereotype
  - getExecutable
```
public Stereotype getExecutable()
```
    Denotes a program that may be run on a node. Denotes a program file that can be executed on a computer system.Subclass of <>.
    
    Returns:
    stereotype
  - getFile
```
public Stereotype getFile()
```
    A physical file in the context of the system developed.
    
    Returns:
    stereotype
  - getFocus
```
public Stereotype getFocus()
```
    A class that defines the core logic or control flow for one or more auxiliary classes that support it. Support classes may be defined explicitly using Auxiliary classes or implicitly by dependency relationships. Focus classes are typically used together with one or more Auxiliary classes, and are particularly useful for specifying the core business logic or control flow of components during design. See also: auxiliary .
    
    Returns:
    stereotype
  - getFramework
```
public Stereotype getFramework()
```
    A package that contains model elements which specify a reusable architecture for all or part of a system. Frameworks typically include classes, patterns or templates. When frameworks are specialized for an application domain, they are sometimes referred to as application frameworks.
    
    Returns:
    stereotype
  - getImplement
```
public Stereotype getImplement()
```
    A component definition that is not intended to have a specification itself. Rather, it is an implementation for a separate specification to which it has a Dependency.
    
    Returns:
    stereotype
  - getImplementationClass
```
public Stereotype getImplementationClass()
```
    The implementation of a class in some programming language (e.g., C++, Smalltalk, Java) in which an instance may not have more than one class. This is in contrast to Class, for which an instance may have multiple classes at one time and may gain or lose classes over time, and an object (a child of instance) may dynamically have multiple classes. An Implementation class is said to realize a Classifier if it provides all of the operations defined for the Classifier with the same behavior as specified for the Classifier's operations. An Implementation Class may realize a number of different Types. Note that the physical attributes and associations of the Implementation class do not have to be the same as those of any Classifier it realizes and that the Implementation Class may provide methods for its operations in terms of its physical attributes and associations. See also: type .
    
    Returns:
    stereotype
  - getInstantiate
```
public Stereotype getInstantiate()
```
    A usage dependency among classifiers indicating that operations on the client create instances of the supplier.
    
    Returns:
    stereotype
  - getLibrary
```
public Stereotype getLibrary()
```
    Denotes a static or dynamic library. Denotes a static or dynamic library file. Subclass of <>.
    
    Returns:
    stereotype
  - getMetaclass
```
public Stereotype getMetaclass()
```
  - getMetamodel
```
public Stereotype getMetamodel()
```
    A model of a model, that typically contains metaclasses.
    
    Returns:
    stereotype
  - getModelLibrary
```
public Stereotype getModelLibrary()
```
    A package that contains model elements which are intended to be reused by other packages. Model libraries are frequently used in conjunction with applied profiles. This is expressed by defining a dependency between a profile and a model library package, or by defining a model library as contained in a profile package. The classes in a model library are not stereotypes and tagged definitions extending the metamodel. A model library is analogous to a class library in some programming languages. When a model library is defined as a part of a profile, it is imported or deleted with the application or removal of the profile. The profile is implicitly applied to its model library. In the other case, when the model library is defined as an external package imported by a profile, the profile requires that the model library be there in the model at the stage of the profile application. The application or the removal of the profile does not affect the presence of the model library elements.
    
    Returns:
    stereotype
  - getProcess
```
public Stereotype getProcess()
```
    A transaction based component.
    
    Returns:
    stereotype
  - getRealization
```
public Stereotype getRealization()
```
    A classifier that specifies a domain of objects and that also defines the physical implementation of those objects. For example, a Component stereotyped by realization will only have realizing Classifiers that implement behavior specified by a separate specification Component. See specification . This differs from implementation class because an implementation class is a realization of a Class which can have features such as attributes and methods which is useful to system designers.
    
    Returns:
    stereotype
  - getRefine
```
public Stereotype getRefine()
```
    Specifies a refinement relationship between model elements at different semantic levels, such as analysis and design. The mapping specifies the relationship between the two elements or sets of elements. The mapping may or may not be computable, and it may be unidirectional or bidirectional. Refinement can be used to model transformations from analysis to design and other such changes.
    
    Returns:
    stereotype
  - getResponsibility
```
public Stereotype getResponsibility()
```
    A contract or an obligation of an element in its relationship to other elements.
    
    Returns:
    stereotype
  - getScript
```
public Stereotype getScript()
```
    A script file that can be interpreted by a computer system. Subclass of file .
    
    Returns:
    stereotype
  - getSend
```
public Stereotype getSend()
```
    A usage dependency whose source is an operation and whose target is a signal, specifying that the source sends the target signal.
    
    Returns:
    stereotype
  - getService
```
public Stereotype getService()
```
    A stateless, functional component (computes a value).
    
    Returns:
    stereotype
  - getSource
```
public Stereotype getSource()
```
    Denotes a source file that can be compiled into an executable file.Subclass of <>.
    
    Returns:
    stereotype
  - getSpecification
```
public Stereotype getSpecification()
```
    A classifier that specifies a domain of objects without defining the physical implementation of those objects. For example, a Component stereotyped by specification will only have provided and required interfaces, and is not intended to have any realizingClassifiers as part of its definition. This differs from type because a type can have features such as attributes and methods which is useful to analysts modeling systems. Also see: realization
    
    Returns:
    stereotype
  - getSubsystem
```
public Stereotype getSubsystem()
```
    A unit of hierarchical decomposition for large systems. A subsystem is commonly instantiated indirectly. Definitions of subsystems vary widely among domains and methods, and it is expected that domain and method profiles will specialize this construct. A subsystem may be defined to have specification and realization elements. See also: specification and realization .
    
    Returns:
    stereotype
  - getSystemModel
```
public Stereotype getSystemModel()
```
    A systemModel is a stereotyped model that contains a collection of models of the same physical system. A systemModel also contains all relationships and constraints between model elements contained in different models.
    
    Returns:
    stereotype
  - getTrace
```
public Stereotype getTrace()
```
    Specifies a trace relationship between model elements or sets of model elements that represent the same concept in different models. Traces are mainly used for tracking requirements and changes across models. Since model changes can occur in both directions, the directionality of the dependency can often be ignored. The mapping specifies the relationship between the two, but it is rarely computable and is usually informal.
    
    Returns:
    stereotype
  - getType
```
public Stereotype getType()
```
    A class that specifies a domain of objects together with the operations applicable to the objects, without defining the physical implementation of those objects. However, it may have attributes and associations. Behavioral specifications for type operations may be expressed using, for example, activity diagrams. An object may have at most one implementation class, however it may conform to multiple different types. See also: implementationClass .
    
    Returns:
    stereotype
  - getUtility
```
public Stereotype getUtility()
```
    A class that has no instances, but rather denotes a named collection of non-member attributes and operations, all of which are class-scoped.
    
    Returns:
    stereotype
  - generatedGetAllStereotypes
```
protected java.util.Collection<Stereotype> generatedGetAllStereotypes()
```
    Description copied from class: StereotypeByProfileCache
    
    Generated method for getting all stereotypes contained within this profile.
    
    Overrides:
    
    generatedGetAllStereotypes in class StereotypeByProfileCache
    
    Returns:
    gets all stereotypes contained within this profile.
  - isAuxiliary
```
public static boolean isAuxiliary(@CheckForNull
                  Element element)
```
  - isBuildComponent
```
public static boolean isBuildComponent(@CheckForNull
                       Element element)
```
  - isCall
```
public static boolean isCall(@CheckForNull
             Element element)
```
  - isCreate
```
public static boolean isCreate(@CheckForNull
               Element element)
```
  - isDerive
```
public static boolean isDerive(@CheckForNull
               Element element)
```
  - isDestroy
```
public static boolean isDestroy(@CheckForNull
                Element element)
```
  - isDocument
```
public static boolean isDocument(@CheckForNull
                 Element element)
```
  - isEntity
```
public static boolean isEntity(@CheckForNull
               Element element)
```
  - isExecutable
```
public static boolean isExecutable(@CheckForNull
                   Element element)
```
  - isFile
```
public static boolean isFile(@CheckForNull
             Element element)
```
  - isFocus
```
public static boolean isFocus(@CheckForNull
              Element element)
```
  - isFramework
```
public static boolean isFramework(@CheckForNull
                  Element element)
```
  - isImplement
```
public static boolean isImplement(@CheckForNull
                  Element element)
```
  - isImplementationClass
```
public static boolean isImplementationClass(@CheckForNull
                            Element element)
```
  - isInstantiate
```
public static boolean isInstantiate(@CheckForNull
                    Element element)
```
  - isLibrary
```
public static boolean isLibrary(@CheckForNull
                Element element)
```
  - isMetaclass
```
public static boolean isMetaclass(@CheckForNull
                  Element element)
```
  - isMetamodel
```
public static boolean isMetamodel(@CheckForNull
                  Element element)
```
  - isModelLibrary
```
public static boolean isModelLibrary(@CheckForNull
                     Element element)
```
  - isProcess
```
public static boolean isProcess(@CheckForNull
                Element element)
```
  - isRealization
```
public static boolean isRealization(@CheckForNull
                    Element element)
```
  - isRefine
```
public static boolean isRefine(@CheckForNull
               Element element)
```
  - isResponsibility
```
public static boolean isResponsibility(@CheckForNull
                       Element element)
```
  - isScript
```
public static boolean isScript(@CheckForNull
               Element element)
```
  - isSend
```
public static boolean isSend(@CheckForNull
             Element element)
```
  - isService
```
public static boolean isService(@CheckForNull
                Element element)
```
  - isSource
```
public static boolean isSource(@CheckForNull
               Element element)
```
  - isSpecification
```
public static boolean isSpecification(@CheckForNull
                      Element element)
```
  - isSubsystem
```
public static boolean isSubsystem(@CheckForNull
                  Element element)
```
  - isSystemModel
```
public static boolean isSystemModel(@CheckForNull
                    Element element)
```
  - isTrace
```
public static boolean isTrace(@CheckForNull
              Element element)
```
  - isType
```
public static boolean isType(@CheckForNull
             Element element)
```
  - isUtility
```
public static boolean isUtility(@CheckForNull
                Element element)
```

Class StandardProfile

Nested Class Summary

Nested classes/interfaces inherited from class com.nomagic.uml2.ext.jmi.helpers.StereotypeByProfileCache

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.nomagic.uml2.ext.jmi.helpers.StereotypeByProfileCache

Methods inherited from class com.nomagic.magicdraw.utils.StandardObjectHolder

Methods inherited from class java.lang.Object

Field Detail

PROFILE_URI

PROFILE_NAME

AUXILIARY_STEREOTYPE

BUILDCOMPONENT_STEREOTYPE

CALL_STEREOTYPE

CREATE_STEREOTYPE

DERIVE_STEREOTYPE

DESTROY_STEREOTYPE

DOCUMENT_STEREOTYPE

ENTITY_STEREOTYPE

EXECUTABLE_STEREOTYPE

FILE_STEREOTYPE

FOCUS_STEREOTYPE

FRAMEWORK_STEREOTYPE

IMPLEMENT_STEREOTYPE

IMPLEMENTATIONCLASS_STEREOTYPE

INSTANTIATE_STEREOTYPE

LIBRARY_STEREOTYPE

METACLASS_STEREOTYPE

METAMODEL_STEREOTYPE

MODELLIBRARY_STEREOTYPE

PROCESS_STEREOTYPE

REALIZATION_STEREOTYPE

REFINE_STEREOTYPE

RESPONSIBILITY_STEREOTYPE

SCRIPT_STEREOTYPE

SEND_STEREOTYPE

SERVICE_STEREOTYPE

SOURCE_STEREOTYPE

SPECIFICATION_STEREOTYPE

SUBSYSTEM_STEREOTYPE

SYSTEMMODEL_STEREOTYPE

TRACE_STEREOTYPE

TYPE_STEREOTYPE

UTILITY_STEREOTYPE

Constructor Detail

StandardProfile

Method Detail

getInstance

getInstance

getAuxiliary

getBuildComponent

getCall

getCreate

getDerive

getDestroy

getDocument

getEntity

getExecutable

getFile

getFocus

getFramework

getImplement

getImplementationClass

getInstantiate

getLibrary

getMetaclass

getMetamodel

getModelLibrary

getProcess

getRealization

getRefine

getResponsibility

getScript

getSend

getService

getSource

getSpecification

getSubsystem

getSystemModel