(Glossary of the Kmelia Model)

metamodel

• (component) interface : a set of provided service names, a set of required service names
• types : a set of (user) type definitions
• (component) state can be divided into observable/non observable parts
  • constants : a set of triple (name, type, value)
  • variables : a set of couple (name, type)
  • invariant : a set of named Kml predicates
  • initialisation : a set of Kml assignments
• properties : a set of named Kml predicates

• qualifier e.g. required, provided, protocol : an annotation that classify the service. A service has to be either required or provided. A provided service can be qualified as a protocol. some service features varies according to this qualifier
• interface (service dependency)
  • subprovides : a set of provided service names (assumed to be subservices)
  • intrequires : a set of provided service names (assumed to be provided services of the same component)
  • calrequires : a set of required service names (assumed to be provided services or subservices of the CALLER component)
  • extrequires : a set of required service names (assumed to be in the required part of the component interface)
  • I/O messages (New optional feature) : set of message definitions used in the service
    by default msg(ANY)
• Virtual context : only present for a required service
  • variables : a set of couple (name, type)
  • invariant : a set of names Kml predicates
• assertions
  • precondition : a Kml predicate
  • postcondition : a Kml predicate
• eLTS
  • state : a step in the service process (a name)
    • init = 1 state
    • final = set of states
  • transition : a triple (source-state, label, target-state) the label can be an action or a block of actions.

• elementary action : a Kml expression or assignment
• communication action : a message action or a service action channelExpr(comOperator)name(param)
  • message action
    • send a message (comOperator = ?)
    • receive a message (comOperator = !)
  • service action (from the caller point of view)
    • service call (comOperator = !!)
    • service return (comOperator = ??)
  • service action (from the callee point of view)
    • service call (implicitely being in the initial state)
    • service return (comOperator = !!)

service actions are horizontal service structuring mechanisms

The general syntax is

channelExpr:<RoleId>[<selector>](!|?|!!|??)comName(param*)

  * channel
      * caller communication <code>channelExpr = __CALLER</code>
      * internal communication <code>channelExpr = __SELF</code> 
      * external communication <code>channelExpr = _reqServName</code>
  * role (only for shared services) : subset of the callers (see multipart communications)
  * selector (only for shared services) : index in the subset of the callers and maybe roles (see multipart communications)

annotations are vertical service structuring mechanisms

• state annotation / optional behavior : a (sub)provided service is callable in the state

st <<serv_name>>

• transition annotation / mandatory behavior : a (sub)provided service is called during the transition

label = [[serv_name]]

in each case serv_name belongs to the service subprovides interface of the depending service

a subservice (of a service) is a provided service that belongs to the subprovides interface of another provided service.

* protocol : a special kind of provided services of a component whose eLTS includes simple expressions and subservices,
* shared service (see N-part assemblies),
* virtual context,
* query provided service : no side effect

An assembly is a set of component instances definition together with assembly links.

• component instance declaration

  name : ComponentType

• component instance collection declaration

  name[Integer] : ComponentType

• assembly links : a couple a service names (a,b) where one is provided and the other is required, syntactically

direction C1.s1 C2.s2

where direction is p-r or r-p, C1 and C2 are component instance denominations and s1 and s2 are service names.

• a sublink is a link in the context of another link. It is related to service interface.
• context mapping (recent) : a (relational) mapping of the variables of the virtual context of a required service to the component context of a provided service
  

the context mapping is associated to a link.

• message mapping (not accepted yet) : a (relational) mapping of the messages of the required service (or its calling context) to the messages of a provided service
  

the context mapping is associated to a link.

An assembly type is just the generalisation into a reusable structure.

ASSEMBLY typename 
   componentOrAssembly declarations
   links declaration

Hence an assembly can be defined from component instances or assembly instances.

• link : services
• sublinks : (sub) services
• context mapping : from virtual context to concrete context (component ibservable) state)
• message mapping : names and parameter (?)

Pour chacun

• service name mapping : implicite
• service param mapping : adaptation
• context mapping : varvirt = exprvar_conc
• message name mapping : explicite
• message param mapping : adaptation

a voir plus tard : le partage de sous-liens

Assemblage

 ASSEMBLY Stock
 Components
    sm : StockManager;
    ve : Vendor
 Assemblies
    a1 : A1;
    ...
 Links
   l1: p-r sm.newReference, ve.addItem
       context mapping
           ve.catalogEmpty = ...
           ...
       message mapping
           n1 = n2
           ...
       sublinks : {sl1, sl2, ...}

A composition is the encapsulation into a (composite) component of a set of assembly instances definition together with promotion links and promoted (sub)component observable variables.

• assembly instance declaration : <code>ass_name : AssemblyType</code>

  • subcomponent : a component of an assembly instance
  • composite component : a component that results from the composition (SELF)
  • promotion links (service promotion) :

  a couple a service names (a,b) where both are either provided or required, syntactically <code>direction C1.s1 C2.s2</code> where direction is p-p or r-r, C1 and C2 are component instance denominations (either SELF or a subcomponent name) and s1 and s2 are service names.

• observable variable promotion : a variable vi of a subcomponent Ci become visible in the composite level. <code>v : T FROM Ci.vi</code> where the type of vi is compatible with T.

Composition

COMPONENT
...
COMPOSITION
Assembly
   same as assembly
End
Promotion
   Links
   l1: p-r sm.newReference, ve.addItem
       context mapping
           ve.catalogEmpty = ...
           ...
       message mapping
           n1 = n2
           ...
       sublinks : {sl1, sl2, ...}
   Variables
           ve.catalogEmpty = ...
           ...
END_COMPOSITION

• types
• operators
• functions
• predicates
• expressions see details here

• shared service (more than one caller)
• multipart communications (see Channel expression above) and broadcast
• shared links

  • component instance collections

  Aspects
• ComponentAspect
• Adaptors
• Weaving