The root package. See the other packages if you want to browse the classes of Kermeta api.

Contains a set of classes whose function is to evaluate a kermeta
expression written as a string.

Execute the expression given as a string.
the self type and formal parameters are supposed to be set
before calling this operation

Execute the expression in the given context

initialise the formalParameters with an empty set of parameters
and the self type with void

Parse the expression as a string
and updates the expression field and errors
Returns true if the expression was parssed sucessfuly

Parse errors and type errors

the expression

Formal parameters of the expression

The type of the self object
or void if the expression is not to be executed
in the context of an object

DynamicExpression is a class used to make dynamic calls, i.e dynamic evaluation
of Kermeta statements represented in a string.

An example :
var de : DynamicExpression init DynamicExpression.new
de.initializeDefaults
de.formalParameters.put("a", String)
de.parse("stdio.writeln(a)") // note: to execute a list of statements, you have to surround them with do..end
var params : Hashtable<String, Object> init Hashtable<String, Object>.new
params.put("a", "hello world!")
de.execute(void, params)

Contains the classes that handle the serialization of models, in particular
EMF models.

If true, tells to the save of the resources that they should also integrate the resources from Kermeta interpreter itself
this is usefull for example to make a dependency to framework.km
by default, not setting this is considered as false.

Repository that stores and manages resources that come from EMF

Create an hashtable with appropriates keys and empty collections. This method
should not be called by the end-user

Helper that returns true if new_instance type is in the tparam Set, false otherwise
FIXME : Loop-and-cast done in order to temporarily get round the type
system limits for reflection

save and check the resource using the EMF validation function
apply the validate on all the object in the root of this resource
returns true if the validation reports no error
otherwise raises exceptions

Extension of the Resource class definition that is specific to EMF Repository.

Repository that stores and manages XMI files representing Kermeta models

Create a resource with given uri.
params :
- uri : the uri where to save the model handled by the resource
- mm_uri : the uri of the metamodel of which model is an instance
User must provide the mm_uri if he creates a new model from scratch.

Create a new resource for a model given by its uri,
which meta-model is stored in file given by mm_uri
If file already exists, you'll be able to call the load method to concretly load the model
otherwise, you can only call the save method

Get the resource of model that is stored in the given uri.
This suppose that this URI resource was already created in this Repository.
If this resource wasn't already created it will silently create
and load a new one. In this case, the

Get the resource of model that is stored in the given uri. Silently create
and load a new one if a resource with this uri was not found.

The resources created by this repository

Abstract resource container, that contains a list of available loaded resources,
and methods to create or get a resource given an URI.

add an instance, return it if success, otherwise return null
You need to do that for every Object that must be placed in the root of the resource when you'll save it Add an instance to the Resource ( this is only a shortcut to instances.add call)

Loads a resource. Once loaded, you'll be able to query the resource for its content. Loads a resource. Once loaded, you'll be able to query the resource for its instances.

remove the instance, return it if success, otherwise return null Remove an instance from the Resource

Save a model instance, in the file specified by the initial uri
Overrides the old version.
Save a resource in a file referenced by the uri associated to the resource

Save a resource in a file referenced by this new uri.
This allows to save the result of a transformation without changing the original file. Save a resource in a file referenced by this new uri.
This allows to save the result of a transformation without changing the original file.

- returns all the model elements hosted by this resource, including elements from the
dependent resources

- returns the rootContents of the model saved in/loaded from the given uri, including
the models from the dependent resources

The hashtable that contains the contents loaded by the resource.
It is composed of 4 entries : "rootContents", "allRootContents", "contents", "allContents"
The two last ones will be kept empty since resource-heavy
- rootContents : only the root elements of the "main model" hosted by the given resource
- allRootContents : the root elements of the main model

- returns all the model elements hosted by this resource, excluding elements from the
dependent resources

The includedResource if the model-instance "inter-depends" on other instances

The entities contained in the model-instance, that are provided when user loads a resource
instances == rootContents

The uri of the meta-model of the model-instance to load

The repository used to create this resource

- returns the rootContents of the model saved in/loaded from the given uri, excluding
the models from the dependent resources

The uri of the model-instance to load

The main class that handle a loaded/saved model.
There are a few important things to note for the developer :

- load a Resource : this loads a Collection of instances corresponding to the
objects in the loaded model. If the Collection of instances is empty, than
a ResourceLoadException is raised

- save a Resource : this saves the collection of instances in a new file. This can
be correctly done if and only if the instances saved are conform to the metamodel
linked to this resource (this link does not need to be explicit. It is normally retrieved
through the EMF model -- see Java wrapping "Resource.java").

- add/remove an instance to the Resource : this adds an element in the resource. It cannot
be "simply" added because of the following potential errors :

- The object added is not conform to the metamodel -> Error
- The object was already added in the resource -> Not a real error : we do nothing
- The object to remove does not exist -> redirect to a collection-specific error
- The object to remove is attached to an object in the collection -> "dependency-violation" exception?

Specialized exceptions

Raised when user tries to add an object that is not conform to the metamodel

Contains the implementation of a unit test tool. This is a clone of
JUnit architecture.
Reference : http://junit.sourceforge.net/doc/cookstour/cookstour.htm

Usage example of kunit can be found in fr.irisa.triskell.kermeta.samples project.

You can also find a little example if you go to the documentation of the class
TestRunner.

Fails if bool is false

will fail if bool is true

will fail if bool is true

will fail if bool is false

will fail if bool is false

raise a AssertionViolatedException with the provided message

give the order number of the failed assert

The abstract class assert defines a set of convinient operations
to assert expected behavior and give the rank of failed assert

AssertionViolatedException are raised when assertions are violated

Run the test

Execute the test case

Execute all tests of the suite

The main method that the testes has to implement for his specific tests
This method is an adapter that uses the pluggable selector TestCase.name to know which
test to run

Called before a test is run to set up the needed environment

Called each time a test is run so that the testing environment is always
tidy.

Abstract class Test. Interface for single and composite object (TestCase and TestSuite)

Initialize the test case
params :
- name : the name of the test case : must be the name of the testOperation

A name for the test case so that we know which one failed
This is a "pluggable" selector

A test case contains a set of testOperations.
See TestRunner class to find how to run a TestCase.
Related design-pattern : Command

An Example of TestCase :

 class MyTestCase inherits kermeta::kunit::TestCase

 {

    attribute cString : String

 

     method setUp() is do

    cString := "String"

     end



    method tearDown() is do

        // We don't need to tearDown anything in this example.

    end



    operation testStringAssignment() : Void is do

        var aString : String init "String"

        assert(aString==cString)

        // You can also add a message if assert fails :

        assertTrueWithMsg(aString==cString, "expected aString == cString")

     end

 }

An instance of this class is created when an assertion failed or an exception
was raised.

load in the testSuiteClass all the methods prefixed by test
params :
- testCaseClass : the TestCase class where we get the testOperations
// FIXME / I would like to do "TestType inherits TestCase"

Adds a failed test to the list of failed tests

Set the runtests to 0

Increments the runtests counter

tests which errors were not assertion failures

tests which assertions failed

number of test that were run

Get the number of run tests, errors and failures that resulted from the launch of a
Test. (This is a minimal but functional class that can be improved)
Related design-pattern : Collecting parameter

Recursively check if this class inherits from the class TestCase
this function is not really for external usage

Prints in a text format the result of the tests launches
TODO : a specific set of class that inherit TestResult and display
it according to a specific format

Run a test suite from the given test case (test_class should be a class
that inherits TestCase

User instantiates this class to run a TestSuite or a TestCase

Usage :

Create a file, and add in the "require" place :

require "the_file_that_contains_the_tests.kmt"

Create a class, which will be the one that you will launch :

 class MyTesterClass

 {

   operation main() is do

     var testRunner : kermeta::kunit::TestRunner init kermeta::kunit::TestRunner.new

     // Here, we run our test case class called "TestClass", 

     // contained in the_file_that_contains_the_tests.kmt.

     // TestClass must inherit TestCase, or TestSuite

    testRunner.run(TestClass)

    testRunner.printTestResult

 end

 }

 

The set of contained tests

A test suite is composed of a set of tests (which can inherit either of TestSuite
or TestCase)
Related design-pattern : Composite

Contains the implementation of Kermeta reflective collections.

ReflectiveCollection is a special collection that is used to define the type
of attributes that have an upper multiplicity > 1 in a class. It indeed handles
the update of opposite property if such an attribute has got one.

ReflectiveSequence is an ordered ReflectiveCollection.

Contains the definition of a Kermeta exception and a few basic exceptions.

Creation on an abstract class. Usually this is detected by the type-checker. The only
case where this happens is when instantiating a type variable, whose bound type turns
out to be abstract.

Occurs when a feature is called on void

The message attached to the exception

Any nested exception

The stack trace as a String
Filled by the interpreted when the exception is raised

Generic exceptions
The main class from which all the exception inherit

Use this exception whenyou want to forbid the access to an unimplemented operation
and invite to implement it

The code that raised the exception

Exception for interpreter exceptions

Use this exception when user tries to add an element to a property which type is collection
which has an upper bound != -1 ( ie *)

Contains Input/Output related classes.

read an object from standard input

write the object to standard output

writeln the object to standard output

An implementation of StdIO : standard input/output

Contains all the abstract classes used in the reflection mechanism. Implements the derived
properties contained in the classes; declares the abstract operations.
Concrete implementation is in kermeta.language.structure.

Alias for kermeta::standard::Boolean

Returns true if the classDefinition of this class is abstract.

Returns the name of the classDefinition of this class

Returns the attributes, references, and derived properties owned by
the classDefinition of this class.

Returns the operations owned by the classDefinition of this class.

Returns the Classes of which the classDefinition of this class inherits.

Type corresponding to the use of a ClassDefinition (see ClassDefinition)

Returns all the attributes, references, derived properties of this
class definition including the inherited ones

Returns the attributes, references, and derived properties owned by
this class definition.

Returns the operations owned by this class definition.

Returns the Classes of which this class definition inherits.

The definition of a class definition :)

class A

{ 

   attribute s : String

}

   

is a class definition; in :

 main() : A is do end

 

A is a Class : it corresponds to the use of the class definition of A

Constraint is part of a contract implementation in a Class definition or an operation.
Three kinds of constraints are available : pre, post, and inv (invariant constraint)

Special type definition for Enumeration, PrimitiveType

Owned item in enumeration

Definition for enumeration

Item definition for enumeration

Type used to define the use of lambda expressions.
Uses :

operation forAll(func : <G -> Boolean>) : Boolean is do

      var test : Boolean init true

      from var it : Iterator<G> init iterator

      until it.isOff

      loop

         test := test and func(it.next)

      end

      result := test

  end

  

In the above example, <G -> Boolean> is a function type f(G) ->
Boolean, with a parameter of type G and a return type of type Boolean
The operation forAll takes a lambda expression as parameter.

Abstracts the definition of generic type definitions (i.e. type definitions that
can be parameterized), namely, for ClassDefinition and ModelTypeDefinition.

Alias for kermeta::standard::Integer

add an object to the model. According to the ModelType, the typechecker will statically verify if the object can be added or not

add all the Object of the collection that are copmpatible with the ModelDefinition. Other objects are ignored.
Returns the list of Object that have been added (One can check that some element have been ignored or not)

add the Object if it is copmpatible with the ModelDefinition. Other objects are ignored.
Returns the object if it has been added (One can check that some element have been ignored or not)
return Void if not added

returns a set of all the elements of the model that are instance of the given Type

remove an object from the model

Contents of this model ...

Is the holder of a set of model elements (Object) that are compatible with the ModelType that has
instanciated this Model.

Type corresponding to the use of a ModelTypeDefinition

Definition for a model type

Model elements with a multiplicity [lower..upper] inherit this class

Returns the qualified name of this named element. Qualified name is
the list of the names of the packages hierarchically ordered, delimited by
a "::", followed by the name of this named element.

Name of this named element

Any element that contain a name (example : Operation, Property) inherit this
class.

Returns the instances of the given property for this Object.

Example :

 class A { reference attr : String }

 

Using A :

 operation getAProp() is do

    var a : A

    var s : String

    var the_attr : Property init self.getMetaClass.ownedAttribute.one

    s ?= a.get(the_attr)

 end

 

The user has to cast
the result of this method according to the type and the upper multiplicity
of this property. If upper multiplicity > 1, than the effective type of the
result is a Sequence<ThePropertyName>. Otherwise, the type corresponds to
the name of the given Property (i.e the type of the property instance).

Check if the current object is an instance of the given class.

isSameAs operation checks if both objects have the same id

Returns the String representation of this class.
Note : throws an exception if this class has no classDefinition
or if the classDefinition is not well constructed.

Tags are used to put comments/documentation

Object type : all entities of Kermeta metamodel explicitely inherit Object.

Every one knows what an operation is.

Package in kermeta. Each kermeta model must have a root package.

Definition for operation parameter

Abstraction for Parameterized types, namely, Class and ModelType

The class definition for kermeta aliases. Above statement defines a primitive
type called MyString, which instanceType is kermeta::standard::String

alias MyString : kermeta::standard::String

Class representing the property definition. Kermeta<->Ecore equivalence:
- Property with isComposite == true or with type is a base type (String, Integer, Boolean) : EAttribute
- Property with isComposite == false : EReference

Self type : DEPRECATED

Tag is intended to be used to add documentation on a
model element, or add some textual information that cannot be expressed
with any model element definition.

Base class definition for the use of a type.

Phantom class : EMF reflexive editors need that any element of a metamodel
has a direct or indirect containment relationship with the root model element of
the metamodel. This class resolves this technical requirement.

Abstraction for type definitions (ClassDefinition, ModelTypeDefinition, DataType inherit
this class)

Abstraction of the notion of containment for type definitions. Now, kermeta metamodel contains one container
element, that is Package. In a later release, ModelTypeDefinition will be the main container for type and
package definition.

Definition of a type variable for generic types :
in class definition

class AClass<X,Y> {}

, X and Y are type variables.

The type of this model element

Abstraction of the notion of typed element : each element
that is typed inherits this class.

Alias for kermeta::standard::UnlimitedNatural

Class definition for the

Void

type

Contains special classes (Hashtable, Stack) that are not contained in Kermeta
metamodel

Remove all elements from the Hashtable

Tests if a key is present in the table

returns the value for key 'key'

returns an iterator on the keys of the map

Return the keys of the Hashtable

Adds a entry in the Hashtable

Removes the entry which key equals 'key'

returns size of the map

returns an iterator on the keys of the map

Return the keys of the Hashtable

An implementation of hashtable

Get the element at the top of the stack

Get the element at the top of the stack and
removes it from the stack

Push an element in the stack

An implementation of stack

Contains Collections and primitive types, i.e the base types like String,
Integer, etc.

$Id: java.kmt,v 1.1 2006/10/04 11:12:43 dvojtise Exp $
Contains types dedicated to dealing with java objects

returns the intersection of elements and the Bag

returns the intersection of a set of elements and the Bag

returns the union of elements and the Bag

A Bag is a concrete implementation of a Collection

The Boolean type

The class Character

Add an element in the collection

The method 'add' adds the element in the Set
only if it is not yet in the set

Select the method add from Set
Add an element to this collection and update its opposite property if it exists.

Add all elements from the collection elements in the collection

Remove all elements from the collection

returns a new Collection with the results of running collector
once for every element in self.

returns true if the collection contains element

returns true if the collection contains all elements

Returns the nb of instances of 'element' in the collection

Passes each element of the collection to detector.
Returns the first element for which detector is not false.
Returns void if no object matches.

runs func on each element of the collection

returns true if the collection is empty

Returns true if the collection does not contain element

Returns true if the collection contains none of elements

checks that the condition is true for at least one element of the collection
returns false if the collection is empty

checks that the condition is true on all the element of the collection
returns true if the collection is empty

returns an iterator on the collection

returns an element from the collection or void
if the collection is empty

Passes each element of the collection to rejector.
returns a Collection for all elements for which rejector is false

Remove an element from the collection

Passes each element of the collection to selector.
returns a Collection for all elements for which selector is true

returns the number of elements in the collection

Collection is the root abstract class for all kermeta collections

This method should be implemented by any class that inherits
from Comparable.
returns 0 if self = other
returns > 0 if self > other
returns < 0 if self < other

Comparison

Comparaison

Comparaison

return true if self > other

return true if self > other

return true if self >= other

return true if self >= other

return true if self < other

return true if self < other

return true if self <= other

return true if self <= other

The abstract class Comparable defines a set of operation
to compare instances of a class.
Sub-classes only has to implement abstract operation compareTo.
All other methods are defined w.r.t. the compareTo operation

returns self / other

returns self - other

returns self modulo other

returns self * other

returns self + other

Iteration

Convert self as a Real

returns -self

The class Integer

returns true if the iterator has a next element

Returns true if the iterator is on the last element
i.e. returns not self.hasNext()

returns the next element of the iterator

Iterator

The abstract class Numeric is the root class for all
numeric types

adds element in the OrderedCollection at index

Overrides addAt to ensure element uniqueness

returns the element at index in the OrderedCollection

returns the first element in the OrderedCollection

returns the index of the first element instance in the OrderedCollection

returns the last element in the OrderedCollection

removes the element at index of the OrderedCollection

An OrderedCollection is the root abstract class for all ordered Collections.

an OrderedSet is a Set that contained ordered distinct elements, accessible by
their index. (see AddAt method)

The PrimitiveType redefine isSameAs operation from Object class to use in an easier way
primitive types. Comparing two primitive types value can be written as x == y

returns self / other

returns self - other

returns self * other

returns self + other

Convert self as a Real

returns -self

class Real

A Sequence is an ordered collection of elements

returns the intersection of elements and the Set

returns the difference of elements and the Set: the elements of the Set
that are not in elements

returns the union of a set of elements and the Set

returns the union of a bag of elements and the Set

A Set is a collection that contains distinct elements

Appends other at the end of self

returns the character at index in the String

returns the index within this string of the first
occurrence of the specified substring

returns a new string self + other

returns a new string that is a substring of this string

The class String

This special object is used to represent java object that cannot be concretly used with kermeta
the only actions possible on these objects are : assignment and passing them as parameter

Unlimited natural is used for reflection.
It is mapped to integer.equals().
Any negative number is interpreted as '*'

The abstract class ValueType does not contain any feature
but any instance of a sub-class of ValueType will be passed by value
instead of by reference for any other objects.

The class Void
By convention it is a sub-type of everything

Contains all the classes that define the behavior of Kermeta (i.e the model representation
of operation bodies). It is the definition, in kermeta language, of the behavior part of the kermeta
metamodel, viewed as a model.
You can also find some information about the behavior package here : KermetaManual

Assignment is the model-element representation of the assignment statement x := y

Block is the model-element representation for the do...end block.

This expression is a literal representing a Boolean value, typically : true or false keyword

Any callable expression inherits this class, e.g :
- variable call
- feature call ( a.b : b is a feature call)

Tells wether this CallFeature represents a call to @pre in a postcondition

CallFeature is the model element that refers to the use of a feature, i.e either
a property or an operation in a statement. In stdio.writeln("hello"),
writeln is a CallFeature.

This class represents a call to the special internal variable "result" that is used to store the return value of any operation

This class represents a call to the operataion in the parent class
In the following example, the type of super(element) is CallSuperOperation:

class ParentClass {
operation op(element : Integer) : Integer is do
result := element + 1
end
}

class ChildClass {
method op(element : Integer) : Integer is do
result := super(element)
end
}

CallValue refers to the use of the value reserved keyword. This keyword is
only used in the body of the setter part of derived properties.

We call "CallVariable" the use of a variable in a statement.
in i := j + 1, i and j are 2 CallVariables.

Condition is the model-element representation for the

As suggested by its name, this class represents an expression that do nothing. Like a "nop"

The base class for every entity used to define a behavior in operation body.

This expression is a literal representing an Integer value

This class represent a call to an extern Java operation.
This Java operation must be static and have at least one RuntimeO

Implementation of the visitor design pattern on CallFeature objects Implementation of the visitor design pattern on CallFeature objects Implementation of the visitor design pattern on Assignment objects Implementation of the visitor design pattern on Block objects Implementation of the visitor design pattern on Conditional objects Implementation of the visitor design pattern on EmptyExpression objects Implementation of the visitor design pattern on IntegerLiteral objects Implementation of the visitor design pattern on StringLiteral objects Implementation of the visitor design pattern on BooleanLiteral objects Implementation of the visitor design pattern on TypeLiteral objects Implementation of the visitor design pattern on BooleanLiteral objects Implementation of the visitor design pattern on VoidLiteral objects

All classes that can be visited using kermeta::behavior::KMExpressionVisitor must implement this class

This class implements the visitor design pattern for all the classes of this Behavior package, in particular the classes that inherits from kermeta::behavior::Expression

Refers to lambda expression definition (function { e | stdio.writeln(e.toString) })

Refers to parameter definition in lambda expression

Literal refers to String values, Integer values, etc.

Loop refers to from var x : X init a until booleanCondition loop ... end

refers to raise exception block

refers to rescue exception block

refers to self use

This expression is a literal representing a String value, typically : "my string"

The type refered by this literal

This expression is a literal representing a Type.
for example, in
Integer.new
Integer is a type literal representing the type kermeta::standard::Integer

TypeReference refers to the type used in a variable declaration

refers to variable declaration var x : X init a

This class is used to represent the special expression void

Contains the concrete implementation (including the operation bodies)
of the classes of the kermeta::reflection package. If you need
documentation for elements marked as "Undocumented", please take a look
at the kermeta::reflection package which is more complete.

All the classes defined in this kermeta::language::structure package
inherit this class. Part of Visitor pattern implementation.

Implementation of the Visitor pattern for the model elements contained in structure package

class SelfType inherits Type, kermeta::reflection::SelfType, KMStructureVisitable
{
method acceptKMStructureVisitor<ContextType, ResultType>(visitor : KMStructureVisitor<ContextType, ResultType>, context : ContextType) : ResultType from kermeta::language::structure::KMStructureVisitable is
do
result := visitor.visitSelfType(self, context)
end
}

Alias to kermeta::standard::UnlimitedNatural