Package com.nomagic.uml2

Class StandardProfile

java.lang.Object
com.nomagic.profiles.ProfileImplementation
com.nomagic.uml2.StandardProfile
@OpenApiAll public class StandardProfile extends ProfileImplementation

  • Field Details

  • Constructor Details

    • StandardProfile

      public StandardProfile(com.nomagic.profiles.ProfileCache cache)

  • Method Details

    • getInstance

      public static StandardProfile getInstance(BaseElement baseElement)

    • getInstanceByProject

      public static StandardProfile getInstanceByProject(com.nomagic.uml2.project.ElementProject project)

    • auxiliary

      public StandardProfile.AuxiliaryStereotype auxiliary()

    • buildComponent

      public StandardProfile.BuildComponentStereotype buildComponent()

    • call

      public StandardProfile.CallStereotype call()

    • create

      public StandardProfile.CreateStereotype create()

    • derive

      public StandardProfile.DeriveStereotype derive()

    • destroy

      public StandardProfile.DestroyStereotype destroy()

    • document

      public StandardProfile.DocumentStereotype document()

    • entity

      public StandardProfile.EntityStereotype entity()

    • executable

      public StandardProfile.ExecutableStereotype executable()

    • file

      public StandardProfile.FileStereotype file()

    • focus

      public StandardProfile.FocusStereotype focus()

    • framework

      public StandardProfile.FrameworkStereotype framework()

    • implement

      public StandardProfile.ImplementStereotype implement()

    • implementationClass

      public StandardProfile.ImplementationClassStereotype implementationClass()

    • instantiate

      public StandardProfile.InstantiateStereotype instantiate()

    • library

      public StandardProfile.LibraryStereotype library()

    • metaclass

      public StandardProfile.MetaclassStereotype metaclass()

    • metamodel

      public StandardProfile.MetamodelStereotype metamodel()

    • modelLibrary

      public StandardProfile.ModelLibraryStereotype modelLibrary()

    • process

      public StandardProfile.ProcessStereotype process()

    • realization

      public StandardProfile.RealizationStereotype realization()

    • refine

      public StandardProfile.RefineStereotype refine()

    • responsibility

      public StandardProfile.ResponsibilityStereotype responsibility()

    • script

      public StandardProfile.ScriptStereotype script()

    • send

      public StandardProfile.SendStereotype send()

    • service

      public StandardProfile.ServiceStereotype service()

    • source

      public StandardProfile.SourceStereotype source()

    • specification

      public StandardProfile.SpecificationStereotype specification()

    • subsystem

      public StandardProfile.SubsystemStereotype subsystem()

    • systemModel

      public StandardProfile.SystemModelStereotype systemModel()

    • trace

      public StandardProfile.TraceStereotype trace()

    • type

      public StandardProfile.TypeStereotype type()

    • utility

      public StandardProfile.UtilityStereotype utility()

    • getAuxiliary

      @Deprecated public Stereotype getAuxiliary()
      Deprecated.
      use getInstance(element).auxiliary().getStereotype()
      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

    • isAuxiliary

      @Deprecated public static boolean isAuxiliary(@CheckForNull Element element)
      Deprecated.
      use AuxiliaryStereotype.isInstance(element)

    • getBuildComponent

      @Deprecated public Stereotype getBuildComponent()
      Deprecated.
      use getInstance(element).buildComponent().getStereotype()
      A collection of elements defined for the purpose of system level development activities, such as compilation and versioning.
      Returns:
      stereotype

    • isBuildComponent

      @Deprecated public static boolean isBuildComponent(@CheckForNull Element element)
      Deprecated.
      use BuildComponentStereotype.isInstance(element)

    • getCall

      @Deprecated public Stereotype getCall()
      Deprecated.
      use getInstance(element).call().getStereotype()
      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

    • isCall

      @Deprecated public static boolean isCall(@CheckForNull Element element)
      Deprecated.
      use CallStereotype.isInstance(element)

    • getCreate

      @Deprecated public Stereotype getCreate()
      Deprecated.
      use getInstance(element).create().getStereotype()
      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

    • isCreate

      @Deprecated public static boolean isCreate(@CheckForNull Element element)
      Deprecated.
      use CreateStereotype.isInstance(element)

    • getDerive

      @Deprecated public Stereotype getDerive()
      Deprecated.
      use getInstance(element).derive().getStereotype()
      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

    • isDerive

      @Deprecated public static boolean isDerive(@CheckForNull Element element)
      Deprecated.
      use DeriveStereotype.isInstance(element)

    • getDestroy

      @Deprecated public Stereotype getDestroy()
      Deprecated.
      use getInstance(element).destroy().getStereotype()
      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

    • isDestroy

      @Deprecated public static boolean isDestroy(@CheckForNull Element element)
      Deprecated.
      use DestroyStereotype.isInstance(element)

    • getDocument

      @Deprecated public Stereotype getDocument()
      Deprecated.
      use getInstance(element).document().getStereotype()
      A generic file that is not a source file or executable . Subclass of file .
      Returns:
      stereotype

    • isDocument

      @Deprecated public static boolean isDocument(@CheckForNull Element element)
      Deprecated.
      use DocumentStereotype.isInstance(element)

    • getEntity

      @Deprecated public Stereotype getEntity()
      Deprecated.
      use getInstance(element).entity().getStereotype()
      A persistent information component representing a business concept.
      Returns:
      stereotype

    • isEntity

      @Deprecated public static boolean isEntity(@CheckForNull Element element)
      Deprecated.
      use EntityStereotype.isInstance(element)

    • getExecutable

      @Deprecated public Stereotype getExecutable()
      Deprecated.
      use getInstance(element).executable().getStereotype()
      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

    • isExecutable

      @Deprecated public static boolean isExecutable(@CheckForNull Element element)
      Deprecated.
      use ExecutableStereotype.isInstance(element)

    • getFile

      @Deprecated public Stereotype getFile()
      Deprecated.
      use getInstance(element).file().getStereotype()
      A physical file in the context of the system developed.
      Returns:
      stereotype

    • isFile

      @Deprecated public static boolean isFile(@CheckForNull Element element)
      Deprecated.
      use FileStereotype.isInstance(element)

    • getFocus

      @Deprecated public Stereotype getFocus()
      Deprecated.
      use getInstance(element).focus().getStereotype()
      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

    • isFocus

      @Deprecated public static boolean isFocus(@CheckForNull Element element)
      Deprecated.
      use FocusStereotype.isInstance(element)

    • getFramework

      @Deprecated public Stereotype getFramework()
      Deprecated.
      use getInstance(element).framework().getStereotype()
      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

    • isFramework

      @Deprecated public static boolean isFramework(@CheckForNull Element element)
      Deprecated.
      use FrameworkStereotype.isInstance(element)

    • getImplement

      @Deprecated public Stereotype getImplement()
      Deprecated.
      use getInstance(element).implement().getStereotype()
      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

    • isImplement

      @Deprecated public static boolean isImplement(@CheckForNull Element element)
      Deprecated.
      use ImplementStereotype.isInstance(element)

    • getImplementationClass

      @Deprecated public Stereotype getImplementationClass()
      Deprecated.
      use getInstance(element).implementationClass().getStereotype()
      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

    • isImplementationClass

      @Deprecated public static boolean isImplementationClass(@CheckForNull Element element)
      Deprecated.
      use ImplementationClassStereotype.isInstance(element)

    • getInstantiate

      @Deprecated public Stereotype getInstantiate()
      Deprecated.
      use getInstance(element).instantiate().getStereotype()
      A usage dependency among classifiers indicating that operations on the client create instances of the supplier.
      Returns:
      stereotype

    • isInstantiate

      @Deprecated public static boolean isInstantiate(@CheckForNull Element element)
      Deprecated.
      use InstantiateStereotype.isInstance(element)

    • getLibrary

      @Deprecated public Stereotype getLibrary()
      Deprecated.
      use getInstance(element).library().getStereotype()
      Denotes a static or dynamic library. Denotes a static or dynamic library file. Subclass of <>.
      Returns:
      stereotype

    • isLibrary

      @Deprecated public static boolean isLibrary(@CheckForNull Element element)
      Deprecated.
      use LibraryStereotype.isInstance(element)

    • getMetaclass

      @Deprecated public Stereotype getMetaclass()
      Deprecated.
      use getInstance(element).metaclass().getStereotype()

    • isMetaclass

      @Deprecated public static boolean isMetaclass(@CheckForNull Element element)
      Deprecated.
      use MetaclassStereotype.isInstance(element)

    • getMetamodel

      @Deprecated public Stereotype getMetamodel()
      Deprecated.
      use getInstance(element).metamodel().getStereotype()
      A model of a model, that typically contains metaclasses.
      Returns:
      stereotype

    • isMetamodel

      @Deprecated public static boolean isMetamodel(@CheckForNull Element element)
      Deprecated.
      use MetamodelStereotype.isInstance(element)

    • getModelLibrary

      @Deprecated public Stereotype getModelLibrary()
      Deprecated.
      use getInstance(element).modelLibrary().getStereotype()
      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

    • isModelLibrary

      @Deprecated public static boolean isModelLibrary(@CheckForNull Element element)
      Deprecated.
      use ModelLibraryStereotype.isInstance(element)

    • getProcess

      @Deprecated public Stereotype getProcess()
      Deprecated.
      use getInstance(element).process().getStereotype()
      A transaction based component.
      Returns:
      stereotype

    • isProcess

      @Deprecated public static boolean isProcess(@CheckForNull Element element)
      Deprecated.
      use ProcessStereotype.isInstance(element)

    • getRealization

      @Deprecated public Stereotype getRealization()
      Deprecated.
      use getInstance(element).realization().getStereotype()
      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

    • isRealization

      @Deprecated public static boolean isRealization(@CheckForNull Element element)
      Deprecated.
      use RealizationStereotype.isInstance(element)

    • getRefine

      @Deprecated public Stereotype getRefine()
      Deprecated.
      use getInstance(element).refine().getStereotype()
      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

    • isRefine

      @Deprecated public static boolean isRefine(@CheckForNull Element element)
      Deprecated.
      use RefineStereotype.isInstance(element)

    • getResponsibility

      @Deprecated public Stereotype getResponsibility()
      Deprecated.
      use getInstance(element).responsibility().getStereotype()
      A contract or an obligation of an element in its relationship to other elements.
      Returns:
      stereotype

    • isResponsibility

      @Deprecated public static boolean isResponsibility(@CheckForNull Element element)
      Deprecated.
      use ResponsibilityStereotype.isInstance(element)

    • getScript

      @Deprecated public Stereotype getScript()
      Deprecated.
      use getInstance(element).script().getStereotype()
      A script file that can be interpreted by a computer system. Subclass of file .
      Returns:
      stereotype

    • isScript

      @Deprecated public static boolean isScript(@CheckForNull Element element)
      Deprecated.
      use ScriptStereotype.isInstance(element)

    • getSend

      @Deprecated public Stereotype getSend()
      Deprecated.
      use getInstance(element).send().getStereotype()
      A usage dependency whose source is an operation and whose target is a signal, specifying that the source sends the target signal.
      Returns:
      stereotype

    • isSend

      @Deprecated public static boolean isSend(@CheckForNull Element element)
      Deprecated.
      use SendStereotype.isInstance(element)

    • getService

      @Deprecated public Stereotype getService()
      Deprecated.
      use getInstance(element).service().getStereotype()
      A stateless, functional component (computes a value).
      Returns:
      stereotype

    • isService

      @Deprecated public static boolean isService(@CheckForNull Element element)
      Deprecated.
      use ServiceStereotype.isInstance(element)

    • getSource

      @Deprecated public Stereotype getSource()
      Deprecated.
      use getInstance(element).source().getStereotype()
      Denotes a source file that can be compiled into an executable file.Subclass of <>.
      Returns:
      stereotype

    • isSource

      @Deprecated public static boolean isSource(@CheckForNull Element element)
      Deprecated.
      use SourceStereotype.isInstance(element)

    • getSpecification

      @Deprecated public Stereotype getSpecification()
      Deprecated.
      use getInstance(element).specification().getStereotype()
      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

    • isSpecification

      @Deprecated public static boolean isSpecification(@CheckForNull Element element)
      Deprecated.
      use SpecificationStereotype.isInstance(element)

    • getSubsystem

      @Deprecated public Stereotype getSubsystem()
      Deprecated.
      use getInstance(element).subsystem().getStereotype()
      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

    • isSubsystem

      @Deprecated public static boolean isSubsystem(@CheckForNull Element element)
      Deprecated.
      use SubsystemStereotype.isInstance(element)

    • getSystemModel

      @Deprecated public Stereotype getSystemModel()
      Deprecated.
      use getInstance(element).systemModel().getStereotype()
      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

    • isSystemModel

      @Deprecated public static boolean isSystemModel(@CheckForNull Element element)
      Deprecated.
      use SystemModelStereotype.isInstance(element)

    • getTrace

      @Deprecated public Stereotype getTrace()
      Deprecated.
      use getInstance(element).trace().getStereotype()
      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

    • isTrace

      @Deprecated public static boolean isTrace(@CheckForNull Element element)
      Deprecated.
      use TraceStereotype.isInstance(element)

    • getType

      @Deprecated public Stereotype getType()
      Deprecated.
      use getInstance(element).type().getStereotype()
      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

    • isType

      @Deprecated public static boolean isType(@CheckForNull Element element)
      Deprecated.
      use TypeStereotype.isInstance(element)

    • getUtility

      @Deprecated public Stereotype getUtility()
      Deprecated.
      use getInstance(element).utility().getStereotype()
      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

    • isUtility

      @Deprecated public static boolean isUtility(@CheckForNull Element element)
      Deprecated.
      use UtilityStereotype.isInstance(element)

    • generatedGetAllElementWrappers

      protected Collection<com.nomagic.profiles.ProfileImplementation.ProfileElementWrapper> generatedGetAllElementWrappers()

    • generatedGetAllStereotypes

      protected Collection<Stereotype> generatedGetAllStereotypes()