ontologies reasoning components agents simulations architectural modeling with uml2 composite...
TRANSCRIPT
OntologiesReasoningComponentsAgentsSimulations
Architectural Modeling Architectural Modeling withwith
UML2 Composite UML2 Composite Structures and Structures and ComponentsComponents
Jacques Robin
OutlineOutline
UML2 Structured Classifiers Key Concepts Concrete Visual Syntax and Examples Meta-Model Link between Meta-Model and Visual Syntax
UML2 Encapsulated Classifiers Key Concepts Concrete Visual Syntax and Examples Meta-Model Link between Meta-Model and Visual Syntax
UML2 Components Key Concepts Concrete Visual Syntax and Examples Meta-Model Link between Meta-Model and Visual Syntax
UML2 Structured ClassifiersUML2 Structured Classifiers
New to UML2 A UML2 structured classifier C can have special properties called parts
that can be connected within the containing context of C to realize one of its behaviors
The part-whole relationship between a part and its containing structured classifier is distinct but derived from the composition relationship between a class and its composite containing class Whereas a composition property of a kernel classes represents a context-
independent relationship from the kernel “whole” class to the “part” class, the part property of a structured classifier represents a context-dependent
relationship from a structured “whole” class to the “part” class Similarly, the connection relationship between two parts of a
containing structured classifier is distinct but derived from the association relationship between two classes Whereas an association represents a context-independent relationships
between two classes, the connection between two classes that are parts of a containing
structured classifier is valid only within the context of this container
Name
Attributes
Operations
NestedClassifiers
Parts
UML2 Structured Classifier UML2 Structured Classifier CompartmentsCompartments
Nested Classes, Components, Interfaces &Associations linking their attributes,Realizations, Usages & GeneralizationsEncapsulated within containing Kernel::Class
Classes, Components, Interfaces &Connectors linking them as partsor elements connected to parts incontext of containingCompositeStructures::Class
Composed Class x Structured ClassComposed Class x Structured Class
Composition: context independentwhole-part relationship
Association: context independentrelationship
StructuredClass/Part: context-dependentwhole-part relationship
Connector: relationshipdependent ofcontainingStructuredClass
StructuredClass/ClassConnectedToPart: relationshipdependent ofcontainingStructuredClass
Parts Compartment
*
Structured Class: Meta-ModelStructured Class: Meta-Model
StructuredClassifier
Classifier
ConnectableElement
TypedElement
StructuralFeature
Property
Connector
0..1 ownedAttribute *
0..1 /part *
0..1 ownedConnector *ConnectorEnd
role
/definingEnd
Associationtype
0..1 attribute *
0..1 partWithPort
redfinedConnector
*2..**
Type
Kernel::Class
0..1 type
/role
MultiplicityElementFeature
EncapsulatedClassifier
EncapsulatedClassifiers::Class
Class x Composite StructureClass x Composite StructureDiagrams: Link to Meta-ModelDiagrams: Link to Meta-Model
CS::Class.nameCS::ClassCS::Class.part = Property
CS::Class.ownedConnector.ConnectorEnd.role = Property
CS::Class.role.upper= CS::Class.role.lower= Integer
CS::Class.ownedConnector.ConnectorEnd = ConnectorEnd
CS::Class.ownedConnector= ConnectorCS::Class.ownedConnector.name
CS::Class.ownedConnector.type.name
CS::Class.role = Property
CS::Class.part.type = K::Class
K::Class
K::Class.ownedAttribute.isComposite = true
K::Class.ownedAttribute.association = Association
K::Class.ownedAttribute.association = Association
K::Class.ownedAttribute.association.name
K::Class.ownedAttribute.upper= K::Class.ownedAttribute.lower
K::Class.name
K::Class.name
K::Class.ownedAttribute.name
Composite Structure Diagram: Composite Structure Diagram: ClassesClasses
Composite Structure Diagram: Composite Structure Diagram: ObjectsObjects
InstanceSpecification
PackageableElement Element
SlotValueSpecification
Classifier
StructuralFeature
LiteralSpecification
InstanceValue
OpaqueExpression
LiteralBoolean
LiteralInteger
LiteralString
LiteralUnlimitedNaturalExpression
0..1
*
0..1 *0..*
*
0..1TypedElement
Class
Composite Structure Diagram: Composite Structure Diagram: ObjectsObjects
InstanceSpecification
PackageableElement Element
SlotValueSpecification
Classifier
StructuralFeature
LiteralSpecification
InstanceValue
OpaqueExpression
LiteralBoolean
LiteralInteger
LiteralString
LiteralUnlimitedNaturalExpression
0..1
*
0..1 *0..*
*
0..1TypedElement
Class
NamedElement
InstanceSpecification.classifier.ownedConnector.name
InstanceSpecification.classifier.nameInstanceSpecification.classifier.parts.role.name
InstanceSpecification.classifier.parts.name
UML2 Encapsulated ClassUML2 Encapsulated Class
New to UML2 Specializes Structured Classifier An instances of an encapsulated class (encapsulated object)
interacts with its environment and its internal parts only through typed interaction points called ports
A port is an interaction point specification used by an encapsulated class to either: Provide a service to its environment specified by a provided
interface that types the port Request a service from its environment specified by a requested
interface that types the port Ports provide a second level encapsulation indirection beyond
the first one provided by interfaces: Encapsulated parts are connected indirectly through their ports, whereas simple parts are connected directly.
UML2 PortsUML2 Ports
Ports allow run-time assembly of encapsulated classes into a containing class to compose a complex service from simpler ones
Instantiation of an encapsulated class with internal parts which are recursively encapsulated class is a complex process that involves: Instantiating each nested encapsulated class Instantiating each of their ports into an interaction point Instantiating each of their associations into a connector between two such interaction
points In this internal assembly process, two ports can only be connected only if the
provided interface of one is conformant to the requested interface of the other This conformance can be:
Simple, merely in terms of matching interface types More complex in terms of pre and post-condition constraints on each operation of the
ports’ respective interfaces Even more complex in terms of protocol state machines associated to either the ports
or their interfaces A protocol state machine describes a precise, constrained sequence of
externally visible states through which the encapsulated class can go through It specifies for each state in the sequence the restricted subset of operations that can
be invoked by the encapsulated class’ environment through the provided port It also specifies the next state resulting from the invocation of a given operation in a
given state
Name
Attributes
Operations
NestedClassifiers
Parts
UML2 Encapsulated Classifier UML2 Encapsulated Classifier CompartmentsCompartments
Classes, Connectors linking them throughtheir Ports as parts or elements connected to partsin context of containing CompositeStructures::Class
Nested Classes, Generalizations, Ports, Associations linking their attributes, Encapsulated within containing Kernel::Class
Ports
*
Encapsulated Class: Meta-ModelEncapsulated Class: Meta-Model
StructuredClassifier
Classifier
ConnectableElement
TypedElement
StructuralFeature
Property
Connector
0..1 ownedAttribute *
0..1 /part *
0..1 ownedConnector *ConnectorEnd
role
/definingEnd
Associationtype
0..1 attribute *
0..1 partWithPort
redfinedConnector*2..*
*
Type
Kernel::Class
0..1 type
/role
MultiplicityElementFeature
EncapsulatedClassifier
EncapsulatedClassifiers::Class
Port
ownedPort
Interface
* /required *
* /provided *
redfinedPort
ProtocolStateMachineprotocol
* protocol 0..1
StateMachine
ProtocolConformance0..1 0..1
Relationship
*
*
0..1conformancespecificMachine
generalMachine *
*
Composite Structure Diagram with Composite Structure Diagram with Encapsulated Classes: Link to Meta-ModelEncapsulated Classes: Link to Meta-Model
CS::Class.ownedPort.type= CS::Class.ownedPort.providedInterface-> union(CS::class.ownedPort.requiredInterface)
Class.ownedConnector.ConnectorEnd.partWithPort
Class.ownedConnector.ConnectorEnd.partWithPort.name
Class
Class
Class
Class.ownedPort.providedInterface
Class.ownedPort.requiredInterface
Class.ownedPort.requiredInterface.name
Class.ownedPort.providedInterface.name
Class.ownedPort
Class.ownedPort.name
Class.part Class.part
Class.part Class.part
Class.ownedConnector
Class.ownedConnector.name
Class.ownedConnector.ConnectorEnd
Class.role Class.part.type = Class
Class.ownedConnector.ConnectorEnd.upper = Class.ownedConnector.ConnectorEnd.lower
Class.name
Class.name
Class.name
Composite Structure Diagram with Composite Structure Diagram with Encapsulated Classes: More Encapsulated Classes: More
ExamplesExamples Part multiplicity can also
appear in the top right corner of the part rectangle
The type of a port can also appear after its name and “:”
The multiplicity of a port can also appear after its name or type between “[ ]”
The service provided by an encapsulated class C by connecting to one of its port can be realized either: By one (or several) part(s) of
C By C itself, in this case the
port square is linked by a line to a state appearing inside C’s part compartment
UML2 ComponentsUML2 Components
New to UML2 for all lifecycle stages except deployment Specialize encapsulated classes The behaviors that it provides to its environment are only accessible
through its provided interface(s) The behaviors that it expects its environment to provide to it are only
accessible through its required interface(s) Through these associated interfaces, a UML2 component defines an
abstract behavioral type independent of its realization The interfaces of a UML2 component can be either:
Directly associated to it, or Indirectly associated to it through its ports.
The abstract behavior type specified by a UML2 component can be realized either: Directly by the component itself; Indirectly by the assembly of its internal parts; Indirectly by a set of external classifiers.
A UML2 packageable component specializes a UML2 component by grouping all the artifacts involved in the component specification or realization into a package
UML2 ComponentsUML2 Components
A UML2 component may: Delegate part of the realization of a service that it provides to its
environment to one of its internal parts; Delegate a service request from one of its part to its environment.
Component connectors specialize encapsulated class connectors by: Being associated to a behavior designed by contract
i.e., it guarantees to its environment that all post-conditions of all its provided operations will be satisfied whenever they are called in a way that satisfies all their pre-conditions;
i.e., its environment guarantees that all post-condition of all its requested operations will be satisfied whenever it calls these operations in a way that satisfies all their pre-conditions;
Sub-categorizing into: Delegation connector between a containing component and its parts; Assembly connector between two parts of an containing component
<<component>>Name
Attributes
Operations
NestedClassifiers
Parts
UML2 Component CompartmentsUML2 Component Compartments
Classes, Components, Interfaces &Connectors linking them throughtheir Ports as parts or elementsconnected to parts in context ofcontaining CompositeStructures::Class
Nested Classes, Components, Ports, Interfaces & Associations linking their attributes,Realizations, Usages & GeneralizationsEncapsulated within containing Kernel::Class
Ports
UML2 Component: Meta-ModelUML2 Component: Meta-Model
EncapsulatedClassifier
EncapsulatedClassifiers::Class
Port
ownedPort
Interface
* /required *
* /provided *
redfinedPort
*
*
0..1
Component
/required
/provided
* *
StructuredClassifier
CS::Connector0..1 ownedConnector *
Components::Connector
kind:ConnectorKind
<<enumeration>>ConnectorKind
assemblydelegate
0..1 /ownedConnector *
Behavior
contract *
*ComponentRealization
Realization
0..1
*
PackageableElement
0..1
*packagedElement
Component Diagram without Component Diagram without Interface Operations: Link to Meta-Interface Operations: Link to Meta-
ModelModel
Component
Component.name
Component.providedInterface
Component.providedInterface
Component.providedInterface.name
Component.providedInterface.name
Component.requiredInterface
Component.requiredInterface
Component.requiredInterface
Component.requiredInterface.name
Component.requiredInterface.name
Component Diagram with Interface Component Diagram with Interface Operations: Link to Meta-ModelOperations: Link to Meta-Model
Component
Component.name
InterfaceRealization
Usage
Component.providedInterface Component.requiredInterface
Component.requiredInterface.nameComponent.providedInterface.name
Component.providedInterface.operation
Component Diagram Nested Component Diagram Nested Classifiers Compartment: Link to Classifiers Compartment: Link to
Meta-ModelMeta-Model
Component
Component.name
NestedClassifiersCompartment
Component.nestedClassifier.ownedAttribute.isComposite = true
Component.nestedClassifier= Class
Component.nestedClassifier= Class
Component.nestedClassifier= Association
Component.nestedClassifier.name
Component.nestedClassifier.name
Component.nestedClassifier.ownedAttribute.upper= Component.nestedClassfier.ownedAttribute.lower
Component.providedInterface
Component.providedInterface.name
Component.requiredInterface.name
Component.requiredInterface
Component.nestedClassifier.ownedAttribute.name
Component Diagram Parts Component Diagram Parts Compartment: Link to Meta-ModelCompartment: Link to Meta-Model
Component.ownedPort
Component.ownedPort
PartsCompartment
Component.ownedConnector
Component.ownedConnector
Component.part.type = Component
Component.part.type = Component Component.part.type = Component
Component.part.type.name
Component.part.type.name Component.part.type.name
Component.ownedConnector.kind = #delegate
Component.ownedConnector.kind = #delegate
Component.ownedConnector.kind = #assembly
Component.ownedConnector.ConnectorEnd.type
Component.ownedConnector.ConnectorEnd.type
Component.name
Component
Component.providedInterface
Component.providedInterface.name
Component.requiredInterface
Component.requiredInterface.name