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