UCD.mc4

/* (c) https://github.com/MontiCore/monticore */

/* This is a MontiCore stable grammar.
 * Adaptations -- if any -- are conservative. */

/*
 * This grammar defines a textual representation of
 * use case diagrams (UCDs).
 *
 * This grammar defines the syntax for UCD artifacts, UCDs, use cases,
 * actors, extend relations, includes relations, and associations between 
 * use cases and actors.
 *
 * This grammar extends the grammar
 *  * BasicSymbols for reusing the Diagram symbol kind.
 *  * MCBasicTypes for reusing import statements and package declarations.
 *  * CommonExpressions for reusing expressions that can be used as 
 *    preconditions for use cases or conditions on extend relations. 
 *  * MCCommonLiterals for reusing literals (i.e., BooleanLiteral).
 */
grammar UCD extends de.monticore.symbols.BasicSymbols, 
                    de.monticore.types.MCBasicTypes, 
                    de.monticore.expressions.CommonExpressions, 
                    de.monticore.literals.MCCommonLiterals {

  /**
   * An artifact containing a use case diagram.
   * @attribute MCPackageDeclaration The package of the use case diagram.
   * @attribute MCImportStatement The import statements of the diagram.
   * @attribute UseCaseDiagram The use case diagram in the artifact.
   */
  UCDArtifact =
    MCPackageDeclaration?
    MCImportStatement*
    UseCaseDiagram;

  /**
   * A use case diagram. 
   * Each use case diagram introduces a Diagram symbol.
   * @attribute Name The name of the use case diagram.
   * @attribute UCDElement Elements contained in the diagram. 
   */ 
  UseCaseDiagram implements Diagram =
    "usecasediagram" Name "{"
      UCDElement*
    "}";

  /**
   * Elements contained in use case diagrams. 
   */ 
  interface UCDElement;

  /**
   * An use case.
   * Each use case introduces an UCDUseCaseSymbol.
   * @attribute abstract True iff the actor is abstract.
   * @attribute Name The name of the use case.
   * @attribute Expression Precondition that must be satisfied to execute
   *            the use case. Variables used in the expression are
   *            interpreted to be of type boolean and are implicitly
   *            introduced by their usage.
   * @attribute sup Names of use cases extended by the use case.
   * @attribute UCDExtend List of use cases to which there exists an
   *            extend. Extend may be guarded.
   * @attribute incl List of use cases included by the use case.
   */
  symbol UCDUseCase implements UCDElement =
    ["abstract"]? Name ("[" Expression "]")?
    ("specializes" sup:(Name@UCDUseCase || ",")+)?
    ("extend" (UCDExtend || ",")+ )?
    ("include" incl:(Name@UCDUseCase || ",")+ )?
    ";";

  /**
   * An extend or an include used in UCDUseCase.
   * If the Expression is present, then the UCDConstrainedUC usage
   * represents an extend. Otherwise, it represents an include.
   * @attribute Name Target use case name of the extend or include.
   * @attribute Expression Condition that must be satisfied to execute the
   *            extending use case when the extended use case is executed.
   *            Variables used in the expression are interpreted to be of
   *            type boolean and are implicitly introduced by their usage.
   */
  UCDExtend =
    Name@UCDUseCase ("[" Expression "]")?;

  /**
   * An actor.
   * @attribute abstract True iff the actor is abstract.
   * @attribute Name The name of the actor.
   * @attribute sup Names of the actors extended by the actor.
   * @attribute uc Names of use cases associated to the actor. The use
   *            cases are implicitly defined by their usage. Thus,
   *            UCDUseCaseSymbol may be defined (if they are not already
   *            defined via the usage of UCDUseCase).
   */
  symbol UCDActor implements UCDElement =
    ["abstract"]? "@" Name
    ("specializes" sup:(Name@UCDActor || ",")+)?
    ("--" uc:(Name@UCDUseCase || ",")+)?
    ";";
}