====== Kmelia Glossary  ======

(//Glossary of the Kmelia Model//)

===== Overview =====

[[metamodel]]

===== Component =====

  * (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

===== Service =====


==== Basics ====

  * 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.


==== Action ====
    * 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**

==== Channel expression ====

The general syntax is 
<code>channelExpr:<RoleId>[<selector>](!|?|!!|??)comName(param*)</code>

      * 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)

==== Annotation ====
annotations are **vertical service structuring mechanisms**
  * state annotation / optional behavior : a (sub)provided service is callable in the state
<code>st <<serv_name>></code>
  * transition annotation / mandatory behavior : a (sub)provided service is called during the transition
<code>label = [[serv_name]]</code>

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

==== Subservice ====

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




==== Extension ====

    * 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

===== Assembly =====

==== Basics ====

An assembly is a set of component instances definition together with assembly links.
  * component instance declaration <code>name : ComponentType</code> 
  * component instance collection declaration <code>name[Integer] : ComponentType</code> 
  * assembly links : a couple a service names (a,b) where one is provided and the other is required, syntactically
<code>direction C1.s1 C2.s2</code> 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.

==== Assembly (Type) ====

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

<code>ASSEMBLY typename 
   componentOrAssembly declarations
   links declaration
</code> 

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


==== Assembly (matching) ====

  * 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 : var_virt = expr_var_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, ...}


===== Composition =====

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



===== Datatypes and Predicates =====

  * types
  * operators
  * functions
  * predicates
  * expressions
 see details [[kmelia:types:start|here]]

===== N-part assembly =====

  * shared service (more than one caller)
  * multipart communications (see Channel expression above) and broadcast
  * shared links 
  * component instance collections

===== Aspects =====

  * ComponentAspect
  * Adaptors
  * Weaving