UML syntax: Dependency relationship

[ronaldtse]

Dependencies

• Def.- A dependency is a relationship between one (or several) source elements and one (or several) target elements.
• The target elements are required for the specification or implementation of the source elements.
• The source elements are incomplete without the target elements.

Notation & Semantics

• A dependency is represented by a dashed arrow, where the arrow points from the dependent element to the independent element.

class dependent
class independent
dependent ..> independent

---

class dependent
class independent1
class independent2
dependent ..> independent1
dependent ..> independent2

• The type of dependency can be specified by using a keyword or stereotype.

Causes of Dependencies

• A package depends on another package.
• A class uses a specific interface to another class. If the interface is changed, then changes are also required in the class that uses this interface.
• An operation depends on a class. (e.g. The class is used in an operation parameter).

Types of dependency relationships

• Abstraction relationship: dependency relationship between model elements at various abstraction levels. Used with a stereotype. Default stereotypes: <>, <> and <>.

• An abstraction relationship always has a mapping rule, specifying how the participating elements relate to one another (formal o informal).

• The relationship can also be bidirectional, depending on the stereotype and mapping rule.

• A special abstraction relationship is realization, a relationship between an implementation an its specification element.

• A substitution relationship specifies that instances of the independent element can be substituted by instances of the dependent element at runtime. (e.g. When the elements implement the same interfaces).

class List
class SortableList
SortableList ..> (substitute) List

• A usage relationship is a special dependency relationship limited to the implementation and it doesn’t apply to specification. This means that the dependent element requires the independent element for its implementation.
  • More specifically, there can be no usage relationship between interfaces but there can be a dependency relationship

class List
class Order
Order ..> (use) List

• A permission relationship is a special dependency relationship that allows the dependent element to access the independent element.
  • In the example Boss obtains the right to access the class Employee (including the private attribute salary).

class Boss
class Employee {
  +name
  -salary
}
Boss ..> (permit) Employee

• An example using the dependency relationship: a design class and its optimized implemention. A text comment is often very helpful.

class Boss
class Tariffing
association {
  from Boss
  to Tariffing
  type dependency(derive)
  comment 'Optimized performance (i.e. The calculation now uses locally replicated data)'
}

Keyword/Stereotype	Description
<<call>>	Stereotype to usage relationshipIs defined and specified from one operation to another operation, so that the source operation calls the target operation. The source can also be a class (the class contains an operation that calls the target operation)
<<Create>>	Stereotype to usage relationship. The dependent element creates instances of the independent element. Is delined between classifiers
<<derive>>	Stereotype to abstraction relationship. The dependent element is derived from the independent element
<<instantiate>>	Stereotype to usage relationship. The dependent element creates instances of the independent element. Is defined between classifiers.
<<permit>>	Keyword for permission relationship. The dependent element is permitted to use private of this independent element
<<refine>>	Stereotype to abstraction relationship. The dependent element resides on a more concrete semantic level than the independent element
<<trace>>	Stereotype to abstraction relationship. The dependent element leads to the independent to trace semantic dependencies (e.g. From a use case to a class)
<<use>>	Keyword fo usage relationship. The dependent element uses the independent element for its implementation

[w00lf]

class Boss
class Employee {
  +name
  -salary
}
Boss ..> (permit) Employee

@ronaldtse ucd gem already have this syntax for defining dependency:

class Boss {
   dependency Employee
}
class Employee {
  +name
  -salary
}

[ronaldtse]

OK, let's adopt this syntax. But where do you write <<permit>>?

[w00lf]

OK, let's adopt this syntax. But where do you write <<permit>>?

In that case, we can use the explicit syntax as described in https://github.com/lutaml/lutaml-uml/issues/23#issuecomment-671696360

[ronaldtse]

Sounds good. @w00lf once the decision is made could you please help move it to the specification document? Thanks!

[w00lf]

Sounds good. @w00lf once the decision is made could you please help move it to the specification document? Thanks!

Ok, will do