UML PSM

UML Protocol State Machines

• always defined in the context of a classifier (e.g. a class or interface)
• specifies which operations of the classifier can be called in which state and under which condition
• states of protocol state machine cannot have entry, do and exit behaviors
• protocol state machines cannot have history and deep history pseudo states
• transitions of protocol state machines cannot have effects
• transitions have [precondition]trigger/[postcondition]:

• classifier operations not represented in a protocol state machine do not have an impact on state
• protocol conformance defined explicitly via ProtocolConformance (specific state machine, general state machine tuple)

Use Case In UML 2.0

Use Case in UML 2.0

Use case diagram has below key elements:
1. Actors:
2. Use Cases:
To describe the functionality unit which can be detected by the external world provided by the system. It is depicted to interaction between the system unit and one or more actors who intercts with it.
3. Relationships
1. Extend:
The extend relationship specifies that the behavior of a used case may be extended by the behavior of another use case. It is intended to be used when there is some additional behavior that should be added, possibly conditionally, to the behavior defined in another used case which is meaningful independently of the extending use case. It is something like the relationship between the base interactions(extended use case) and the supplementary services(extending use case).
This relationship also has below elements:
a) Condition: Reference the condition that must be hold when the first extension point is reached for the extension to take place. If no condition is associated with the extend relationship, the extension is unconditional.
b) Extension point. Please see below element on the description.
2. Include
This is quite a simple relationship, in which the behavior of a use case (included use case) can be inserted into behavior of another use case (including use case). The include relationship is extended to be used when there are common parts of the behavior of two or more use cases. This common part is then extracted to a separate use case, to be included by all the base use cases having this part in common. Since the primary use of the include relationship is for reuse of the common parts, what is left in a base use case is usually not complete in itself but dependent on the included parts to be meaningful.
4. Extension points:
Do not confuse it with the extend relationship!
It is a feature indicating a point where the behavior of a use case can be augmented with elements of another (extending) use case. In other words, this point resides in the extended use case, while the extended case adds the behavior at this point. And please also note that the extending case is not aware of the existence of the extending use cases. This is like the trigger point of the base interaction flow.
5. Extension Location
6. Subject:
7. Package: Usually the use case are owned by the package.