Kermeta

Kermeta is a modeling and programming language for metamodel engineering.

History

The Kermeta language was initiated by Franck Fleurey in 2005 within the Triskell team of IRISA (gathering researchers of the INRIA, CNRS, INSA and the University of Rennes 1).

The Kermeta language borrows concepts from languages such MOF, OCL and QVT, but also from BasicMTL, a model transformation language implemented in 2004 in the Triskell team by D. Vojtisek and F. Fondement. It is also inspired by the previous experience on MTL, the first transformation language created by Triskell, and by the Xion action language for UML.

The name Kermeta is an abbreviation for "Kernel Metamodeling" and reflects the fact that the language is conceived as a core for (meta-)modeling. The Breton language consonance of this name is an intentional reflection of the Triskell team's location in Brittany.

Kermeta, and its execution platform under Eclipse is currently available under its version 2.0.4[1] released in 2012. It is open-source, under the Eclipse Public License.

Philosophy

Kermeta is a modeling and aspect oriented programming language. Its underlying metamodel conforms to the EMOF standard. It is designed to write programs which are also models, to write transformations of models (programs that transform a model into another), to write constraints on these models, and to execute them 1). The goal of this model approach is to bring an additional level of abstraction on top of the "object" level and thus to see a given system like a set of concepts (and instances of concepts) that form an explicitly coherent whole, which one will call a model.

Kermeta thus brings:

Characteristics

The main characteristics of the Kermeta language are :

Syntax

The curious reader will find further information on the Kermeta website.

Example (Kermeta 1.4)

package fsm;

require kermeta

using kermeta::standard

class FSM
{
   attribute ownedState : set State[0..*]#owningFSM
   reference initialState : State[1..1] 
   reference currentState : State 

   /**
    * Print the FSM on the standard output
    */
   operation printFSM() is do
       self.ownedState.each 
       { s | 
           stdio.writeln("State : " + s.name)
           s.outgoingTransition.each 
           { t | 
               stdio.writeln("  Transition : " + t.source.name + 
               "-(" + t.input + "/" + t.output + ")->" + t.target.name)
           }
       }
   end
}

class State {
   attribute name : String
   reference owningFSM : FSM#ownedState
   attribute outgoingTransition : set Transition[0..*]#source
   reference incomingTransition : set Transition[0..*]#target
   
   operation step(c : String) : String is do
       // Get the valid transitions
       var validTransitions : Collection<Transition> 
       validTransitions :=    outgoingTransition.select { t | t.input.equals(c) }
       // Check if there is one and only one valid transition
       if validTransitions.empty then raise "No Transition!" end
       if validTransitions.size > 1 then raise "Non Determinism" end
       // fire the transition
       result := validTransitions.one.fire
   end
   
   
}

class Transition 
{
   reference source : State[1..1]#outgoingTransition
   reference target : State[1..1]#incomingTransition
   attribute output : String
   attribute input : String
   
   operation fire() : String is do
       // update FSM current state
       source.owningFSM.currentState := target
       result := output
   end
}

See also

References

  1. ↑ Vojtisek, Didier. "Version 2.0.4 is released !". Retrieved 3 December 2012.

External links

This article is issued from Wikipedia - version of the 5/8/2014. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.