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

@This class is used to workaround an EMF bug, it doesn't really belong to Kermeta 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.



main features of the famous Unit test tool for Kermeta language

process the given condition and react if it is not satisfied

process the two given string and react if they are not equal

process the given condition and react if it is satisfied

process the given condition and react with the given message
if it is satisfied

Log a failure if the two strings are not identical modulo-white-space

process the given condition and react if it is not satisfied

process the given condition and react with the given message
if it is not satisfied

process the given condition and react with the given message
if it is not satisfied

* reduces all runs of white-space to a single space character

to be used if a failure reaction is needed

to be written ############################
@

Fails if condition is false

Will fail if the two strings are not identical

will fail if condition is true

will fail if condition is true

will fail if condition is false

will fail if condition is false

will fail if condition is false

raise a AssertionViolatedException with the provided message

@

AssertionViolatedException are raised when assertions are violated @

Sets up a new error with failable object and the exception that occurred
by default it will be a test error. Use makeSetUp or makeTearDown to
change its type

Changes the type of an error to SetUpError, the best way to use
this method is to call it after the init from line:
var e : Error init Error.new.initFrom(f, e).makeSetUp

Changes the type of an error to makeTearDownError, the best way to use
this method is to call it after the init from line:
var e : Error init Error.new.initFrom(f, e).makeTearDown

overwrite the default method, in order to add :
- the type
- the message
- the stack trace

the stored error

the Kermeta exception corresponding to the error

the nature of the stored error

Error represents an occurrence of an exception in setUp, tearDown or a test
and is stored in a failure log
@

initialization of the failure

overwrite the default method, in order to add the message

the stored failure

the stored message (given or generated one)

Failure represents an assertion failure stored in a failure log
@

Log a failure if condition is false

Log a failure if the two strings are not identical

Log a failure if condition is true

Log a failure if condition is true

Log a failure if condition is false

Log a failure if condition is false

Log a failure if condition is false

Log a failure

where failures will be put

current order position of counter of assertions

counter of assertions in the test method

Set this attribute to false if you wish your test to not stop if the assert fails.
note : if set to false, the count of failures/errors may be bigger that the number of executed test operations

This is represents the aspect of tests that they may go wrong.
it defines the ability to define the conditions for success
(assertions) and the mechanism for recording that those
conditions have not been met.
@

This is for when we try to build a suite from a class that isn't a TestCase
@

This exception is rose if there is a problem on the name of the test method
@

Adds a failed test to the list of failed tests

Adds errors which occur during the SetUp phase

Adds errors which occur during the TearDown phase

Adds an error to the list of errors

Increments the runtests counter

list of detected test errors

list of detected assertion failures

list of detected errors with the test harness

number of test that were run

Log is a log of failures and errors that happened to fallibles since start was called
@

called when run by the java testrunner

Execute the test and verify its assertions

Initializes the log where failures and errors will be put

where failures and errors will be put

The abstact notion of a test which is runnable and which has a log
in which it can keep note of failures
@

accessor on the log

accessor on the method name

operation used when the TestCase is run from a java test runner, encapsulates the failures results
into an AssertionFailedError so the TestRunner can detect it

Execute the whole test case : SetUp, test method, TearDown
The assertions of the test method are computed

Sets the name of the method from the concrete subclass of
TestCase that should be executed when this TestCase instance
is run as a test.
Throws invalidTestCaseNameException if the given string is not
the name of a method in the test case

the things to be done before execution of the test method
(designed to be overwritten in real TestCase classes)

the things to be done after execution of the test method
(designed to be overwritten in real TestCase classes)

overwrites the default method for more informative output

the name of the method which corresponds to the test case in the test class

A test case comprises one or more test methods plus
setUp and tearDown that build and destroy their test harness.
An instance of a subclass of TestCase should have its
testMethodName set to the name of one of its operations
which should be called whe the test is run. You can do this
yourself:

var testCase : TestCase init MyTestCaseClass.new.setTestMethodName("testSomething")

Alternatively if your TestCase Class has many methods whose
name begins with 'test' you can create a set of instaces already
set up with their testMethodName using the addAllTestCasesFrom
operation on TestSuite
@

Prints the log or errors and failures from a test run.
Run some tests first.

For backwards compatibility with old kunit, this takes a test case class
and creates the necessary suite, and runs it. DEPRECATED

Use this to run a test case or a test suite.
If you want to run all the test.... methods in a TestCase class,
you can populate a suite with TestSuite.addAllTestCasesFrom

Where to register the failures and errors

Create and use a test runner to run one or more tests and print the failure log. E.g.:
do
var suite : TestSuite init TestSuite.new.addAllTestCasesFrom(InterestingTestCaseSet)
var runner : TestRunner init TestRunner.new
runner.run(suite)
runner.printLogs
end

Where InterestingTestCaseSet is a subclass of TestCase and contains several test... methods
@

Add to this suite, a set of test cases of type c, one for each
test method in class c. C must be a descendent of TestCase

to be written #####################################################

Run all the tests in the test suite

The collection of tests which will be ran as the suite

A TestSuite is a structured collection of tests, using the
composite pattern, all tests are runnable and have a log
In addition a suite can be populated automatically from a
test case class with one test case object for each test
method in the class.
You can make a suite and populate it manually like this:

var suite : TestSuite init TestSuite.new.
suite.tests.add(t1)

Alternatively you can populate a suite automatically from
a class that inherits TestCase and which has several methods
called test:

var suite : TestSuite init TestSuite.new.addAllTestCasesFrom(InterestingTestCaseSet)
@

@
Contains the implementation of Kermeta reflective collections.

@This class is used to workaround an EMF bug, it doesn't really belong to Kermeta metamodel

Overrides kermeta::standard::Set<G>.add(G)
Add an element to this collection and update its opposite property if it exists.

Overrides kermeta::standard::Collection<G>.clear(G)

Overrides kermeta::standard::Set<G>.remove(G)

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

Overrides kermeta::language::ReflectiveCollection<G>.add(G)

Overrides kermeta::standard::OrderedSet.addAt(Integer)

Overrides kermeta::language::ReflectiveCollection<G>.clear()

Overrides kermeta::standard::OrderedSet.equals(Object)

Overrides kermeta::language::ReflectiveCollection<G>.remove(G)

Overrides kermeta::standard::OrderedSet.removeAt(Integer)

ReflectiveSequence is an ordered ReflectiveCollection.
@

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

@

@

@

@

Instantiates a new occurence for this Class
@

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.

Returns the ClassDefinition for this class

@Returns a Boolean stating whether 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.

@Returns the Attributes, References, and derived Properties owned by
the ClassDefinition of this Class.

Returns all the types directly and indirectly inherited by this ClasDefinition

returns a cached version of the derived property allAttribute
It is intended to be used to optimize access on the reflexivity,
do not use this cache if you are modifying the ClassDefinition

returns a cached version of the derived property allSuperTypes
It is intended to be used to optimize access on the reflexivity,
do not use this cache if you are modifying the ClassDefinition

Data structure for getCachedAllAttribute

Data structure for getCachedAllSuperTypes

Returns all the Attributes, References, derived Properties of this
ClassDefinition including the inherited ones

Returns all the Operations of this ClassDefinition
including the inherited ones

@Invariants defined for this ClassDefinition

@Boolean stating whether the ClassDefinition is abstract (which means that
no instance can be allocated)

@Attributes, References, and derived Properties owned by this ClassDefinition.

@Operations owned by this ClassDefinition.

@Classes from which this ClassDefinition 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

@Body of the constraint, expressed as a KerMeta expression

@Owning ClassDefinition if Constraint corresponds to invariant

@Language in which the constraint is expressed

@Owning Operation if Constraint corresponds to post-condition

@Owning Operation if Constraint corresponds to pre-condition

@Type of the Constraint (precond/postcond/inv)

@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

Implements kermeta::language::structure::Type.clone(Object)
@

@Owned items in an Enumeration

@Definition for Enumeration

@@Owning Enumeration

@Item definition for enumeration

@To be written

@Filter is the class that represent a filter on a ModelingUnit.
the qualifiedName represent the beginning of the matched names

@Parameters of the function (a ProductType for multiple parameters)

@Result type of the function

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

@Type variables defined for the GenericTypeDefinition

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

@

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
instantiated this Model.

To be written ##########################################
@

To be written ##########################################
@

@To be written

@Type of a model, consisting of a set of included type definitions

@To be written

@To be written

@list of filters that apply to this modeling unit.
This means that if the same unit was loaded without this filters, it would have loaded more content
element whose qualified name begins with one of these filter will NOT be loaded in the unit

@list of filters that apply to this modeling unit.
This means that if the same unit was loaded without this filters, it would have loaded more content
only element whose qualified name begins with one of these filter will be loaded in the unit

@root packages contained by this ModelingUnit

@To be written

@Set of "require" statements associated with this ModelingUnit. Ie. list of the other
files required to run this unit

@Set of "using" statement associated with this ModelingUnit. Ie. list of "syntatic shortcut"
that can be used within this unit.

@The modeling unit is the root of any kermeta model. It contains packages, requires and usings.
It also reference others modeling unit.

@Boolean stating whether the element is ordered

@Boolean stating whether duplicated elements are allowed

@Min cardinality of the element

@Max cardinality of the element, '-1' for '*'

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

Implementation of OCL like cast. It returns self if the object object conforms to the type given as parameter.
@

Recursively runs checking of invariants defined for the metaclass of the Object
and its supertypes
Ignores derived attributes.
@

Checks a constraint invariant defined for the metaclass of the Object
You can use PropertyConstraint for checking structural constraints associated to a property
@

Runs checking of invariants defined for the metaclass of the Object
Also check the multiplicity of attributes (except derived and transient attributes)
@

Returns the Object that contains current Object, void if the Object has
no container
@

Returns the Resource currently containing (directly or indirectly) the Object
or void if the object belongs to no Resource
@

semantic equality,
if you wish to test for object identity you need to use the method oid
ex: x.oid == y.oid
by default, (ie. if not overloaded), the equals method for class Object implements
the most discriminating possible equivalence relation on objects; that is, for any non-null
reference values x and y, this method returns true if and only if x and y refer to the same
object (x.oid == y.oid has the value true).

note1: the operator == is mapped to this
note2: overloading this operation have some impact on the behavior on collection and hashtable that rely on it
@

Freeze the Object
@

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).
@

Returns the Class object that is the metaclass of current Object
@

Checks all the invariants for this object and return a complete diagnostic.
This also includes the structural constraints associated to the properties.
@

code used in hashtable in order to identify an object in the hashtable keys
This system is similar to the hashcode used in java. Please refer to java documentation
for more information about hashcode
@

Returns a Boolean stating whether the Object is currently in a
frozen state
@

Returns a Boolean stating whether the current Object conforms to given Type
This means: is this object an instance of this type, or is it an instance of its subtype
@

Returns a Boolean stating whether the current Object is an instance of the given Class

See kermeta::language::structure::Object.equals(Object)
@

True if the ~property of the object has been set
@

Returns a Boolean stating whether the Object is Void
@

Returns the unique Oid of the Object
@

Sets the element to the ~property of the object
@

Implements Object.toString()
Returns a String of form [qn:oid] where 'qn' is the qualified name of
the object type, and oid the unique ID of the object
@

Remove the element set as the ~property of the object.
The isSet(~property) method will then return False
@

@An object can contains a Tag.
Be careful, owning a tag doesn't means that the tag applies to the Object
To know which Tags apply to the object use the "tag" reference

@An Object can be tagged by a Tag.
They are typically used to put comments/documentation on the object

@Object definition: all entities of Kermeta metamodel explicitly inherit from Object

@To be written

@Body of the Operation, expressed as a KerMeta expression

@Boolean stating whether the Operation is abstract

@Parameters of the Operation

@ClassDefinition owning the Operation

@Post-conditions of the Operation

@Pre-conditions of the Operation

@Exceptions raised by the Operation

@Super-operation of the Operation, if any

@TypeParameters of the Operation

@Every one knows what an operation is.

@Nested Packages contained by the Package

@@Owning Package, if any

@Uri of the Package

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

@@Owning operation

@Definition for operation parameter

@Definition of the Type

@Bindings between type variables and provided types

@To be written

@Abstraction for Parameterized types, namely, Class and ModelType

@The type the primitive type is linked with

@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

. Another example could be: root::apackage::AClass

alias MyClass : root::apackage::AClass

, thus a primitive type may be not a subtype of ValueType (ValueType is a concept from the Kermeta framework).

@Types

@Type corresponding to a set of Types
Only used in the context of FunctionType

@

@To be written

@To be written

@Boolean stating whether the Property has a containment role

@If True, the value of the property is not stored but computed from other properties

@Boolean stating wether the getter is abstract.

@Boolean stating whether the property allows to identify its containing Object

@Boolean stating whether the Property is read-only

@Boolean stating wether the setter is abstract.

@Opposite Property of the Property, void if the Property has no opposite

@ClassDefinition that owns the Property

special constraint that apply to this Property
Used by the getViolatedConstraints

@To be written

@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

The property that is checked by this constraint
Typically, it will check the lower and upper bounds

@To be written

@To be written

@

@Name of the Tag

@Objects to which the Tag is attached to

@String value of the Tag

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

Returns a copy of passed Object built by recursively copying attribute
properties, and referencing original reference properties values
@

Returns a copy of passed Object built by recursively copying values of
all properties, no matter the property kind
@

Implements Type.isInstance(Object)
@

Implements Type.isSubTypeOf(Type)
For technical reason, the current implementation works only with Type that comes from a kermeta declaration (ie. in a require)
it won't work with Type created programmaticaly by the user. If you need that, please ask to the kermeta developpers
to extend it.
@

Implements Type.isSuperTypeOf(Type)
For technical reason, the current implementation works only with Type that comes from a kermeta declaration (ie. in a require)
it won't work with Type created programmaticaly by the user. If you need that, please ask to the kermeta developpers
to extend it.
@

@Owning TypeContainer, if any

@Alias to kermeta::standard::IntegerBase class definition for the use of a type.

@Contained types

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

@

@This boolean allows to tell if this Type definition is an aspect or not
If it is an aspect, then at runtime, its definition will be merged with the definition of another
TypeDefinition that has exactly the same qualified nameAbstraction for type definitions (ClassDefinition, ModelTypeDefinition, DataType inherit
this class)

@Contained TypeDefinitions

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

@Reference to the supertype, if any

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

class AClass<X,Y> {}

, X and Y are type variables.

@Assigned Type

@TypeVariable

@Definition of a binding between a TypeVariable and a Type

@Type of the model element

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

@

@To be written

@To be written

@To be written

@To be written

@To be written

@To be written

@Class definition for the

Void

type

@

@Boolean stating whether current assignment corresponds to a cast operation

@Target of the assignment, as a CallExpression

@Value to be assigned, as a KerMeta expression

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

@List of rescues defined for the block

@List of statements composing the block

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

@The concrete value represented by this literal

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

@A call must be named

@Kermeta calls can embedd expressions as parameters

@To be written

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

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

@To be written

@The method which will be executed (operation case)
and the result value passed to the caller

@The object which will be returned (property case)

@Target Expression (the owner of the feature)

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

@Tells whether this CallVariable represents a call to @pre in a postcondition

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

@Condition expression of conditional statement

@Optional else part of the conditional statement

@Then part of the conditional statement

@Condition is the model-element representation for the

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

@Type of the Expression (set by type checking)

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

@The concrete value represented by this literal

@This expression is a literal representing an Integer value

@Qualified name of the targeted Java class

@Name of the Java method to be launched in the identified Java class

@Parameters of the Java static call provided as KerMeta expressions

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

@Body of the lambda expression providede as a KerMeta expression

@Parameters of the lambda expression

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

@Name of the lambda parameter

@To be written ################################

@Refers to parameter definition in lambda expression

@Literal refers to String values, Integer values, etc.

@Body of the loop

@Initialization expression for the loop

@Stop condition of the loop, is interpreted as a Bollean value

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

@To be written #######################

@Refers to raise exception block

@Body of the rescue block, specified as a KerMeta expression

@Name of the catched exception

@Type of the cathed exception

@Refers to rescue exception block

@Refers to self use

@The concrete value represented by this literal

@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

@Initialization expression for the variable
Default value is void ????

@Initialization expression for the variable
Default value is void ????

@Type of the declared variable

@refers to variable declaration var x : X init a

@This class is used to represent the special expression void

Defines value types


Defines Collection types


Contains types dedicated to dealing with java objects

Overrides Collection<G>.asBag()
Returns a new Bag containing all elements of current Bag

Overrides Collection<G>.asOrderedSet()
Returns a new OrderedSet containing elements of the Bag without duplicates

Overrides Collection<G>.asSequence()
Returns a new Sequence containing all elements of current Bag

Overrides Collection<G>.asSet()
Returns a new Set containing elements of the Bag without duplicates

Returns a sequence of the bag elements sorted using the given comparator.
The comparator must return :<ul>
<li>+1 if the second <G> element is greater than the first</li>
<li>0 if the second <G> element equals the first</li>
<li>-1 if the second <G> element is lower than the first</li>

Recursive sort of the given sequence using the given comparator.
The comparator must return :<ul>
<li>+1 if the second <G> element is greater than the first</li>
<li>0 if the second <G> element equals the first</li>
<li>-1 if the second <G> element is lower than the first</li>

Internal concatenation tool for recursive 'quickSort()' method

Overrides Object.equals(elt : Object)
Returns a Boolean stating whether the provided element is equal to
current Bag

Returns a new Bag which content includes the content of the
current Bag from which all instances of object have been
removed

Returns a new Bag which content includes all non-Collection elements
of the current Set, and, for each Collection element of the current
Bag, as many elements as the Collection contains

Returns a new Bag which content includes the content of the
current Bag and the element object

Returns a new Bag corresponding to the intersection of elements
and the Bag

Returns a new Set corresponding to the intersection of a Set of
elements and the Bag

Removes the element identified by the provided Oid from the Bag

Removes one instance of element from the Bag

Returns a new Bag corresponding to the union of elements and
current Bag

Bag is a concrete non-ordered Collection allowing duplicates
@

return self and other

Short-circuit version of AND. This means that the function passed in parameter will be evaluated only if self is true
Note: we don't have a dedicated operator in the syntax for it yet so here is an example of use :
self.andThen{v | functionThatReturnABoolean() }

Returns true if other type is Boolean
and has the same boolean value than current object.

return self implies other
http://en.wikipedia.org/wiki/Material_implication
meaning : (not self) or other

return self nand other

return not self

return self or other

Short-circuit version of OR. This means that the function passed in parameter will be evaluated only if self is false
Note: we don't have a dedicated operator in the syntax for it yet so here is an example of use :
self.orElse{v | functionThatReturnABoolean() }

Returns 'true' or 'false', depending on self value

return self xor other

The Boolean type
@

Comparaison

Returns true if other type is Character
and has the same letter value than current object.

Conversion from Character to String

The class Character
@

Adds an element in the Collection (default implementation)

Adds all elements from the Collection elements in the current Collection

Returns an element from the Collection
Raises an EmptyCollection exception if the Collection is empty

Returns a new Bag built from the Collection

Returns a new OrderedSet built from the Collection

Returns a new Sequence built from the Collection

Returns a new Set built from the Collection

Removes all elements from the Collection

Returns a new Sequence which content corresponds to the result
of running the collector function for each element of the Collection
The new collection size is the same as in the original collection, and which element types is the type of the result of the expression.
example :
aCollection2 := aCollection.collect { e | \/* put here an expression, for example e.name *\/ }

Returns a Boolean stating whether the Collection contains at least one
instance of element, based on G.equals(elt : Object) definition
Note: for checking whether a physical element is contained by the collection,
make use of G.oid()

Returns true if current Collection contains all elements of Collection elements
See Collection<G>.contains(Object)

Returns the number of instances of element in the Collection

Returns an element of the Collection (usually the first) for which the detector function
is not false
Returns void if no elements is validated by the detector function
example :
anObject := aCollection.detect { e | \/* a condition *\/} // returns an element that fulfill the condition.

Runs function func on each element of the Collection
example :
aCollection.each { e | \/* do something with each element e of this collection *\/ }

Returns a Boolean stating whether the Collection is empty

Returns true if the Collection does not contain element

Returns true if the Collection contains no element of Collection elements

Returns a Boolean stating whether at least one element of the Collection
validates the condition specified by function func
example :
aBoolean := aCollection.exists { e | \/* a condition *\/} // returns true if at least one element fulfill the condition.

Combinaison of exists on two elements in the collection
=> result := self.exists{x | self.exists {y | f(x,y)}}

Returns a Boolean stating whether no element of the Collection invalidates
the condition specified by function func
example :
aBoolean := aCollection.forAll { e | \/* put here a condition *\/ } // return true if the condition is true for all elements in the collection.

Combinaison of ForAll on two elements in the collection
result := self.forAll{x | self.forAll {y | f(x,y)}}
(where x and y are 2 elements of the Collection)
typical use sample : ownedState.forAll{s1,s2| (s1.name==s2.name)implies(s1==s2)}

OCL API alignment, doeas the same as contains
See Collection<G>.contains(Object)

OCL API alignment, does the same as containsAll
See Collection<G>.containsAll(Collection<G>)

Runs function func on each element of the Collection
the eachContext contains some information about the each process that can be used in the function,
for example the index represents the rank in the collection, start on 0
or boolean to indicates weither we are processing the first and/or the last element of the collection
note that this rank is relative to the processing order. this processing order is ensured only for sequence and ordered set

example :
aCollection.indexedEach { e, eachContext | \/* do something with each element e of this collection *\/ }

OCL alignment API, does the same as empty
See Collection<G>.empty()

OCL alignment API
Returns a Boolean stating whether the Collection contains at least
one element
See also Collection<G>.contains(Object)

Returns a Boolean stating whether the the collector function evaluates to a
different value for each element of the Collection
example :
aCollection2 := aCollection.isUnique { e | \/* put here an expression that must be unique for all elements, for example e.name *\/ }

Returns an Iterator on the Collection

Returns an element from the Collection or void if the Collection is empty

Returns a new Sequence composed of elements of the Collection that
do not validate the rejector function
example :
aCollection2 := aCollection.reject { e |
\/* put here a condition that returns true for elements that must be exclude in the resulting Collection *\/
}

Removes all instances of element from the Collection, based on
G.equals(Object) definition

Returns a new Sequence composed of elements of the Collection that
validate the selector function
example :
aCollection2 := aCollection.select { e |
\/* put here a condition that returns true for elements that must be included in the resulting Collection *\/
}

Returns the number of elements in the Collection

Sum the element if they are summable (ie implement '+' operator by inheriting of the class Summable)

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

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
@

context used in the indexedEach of Collection
@

Comparison

returns self / other

Returns true if other type is Integer or Real
and has the same numeric value than current object.

return true if self > other

return true if self >= other

return true if self < other

return true if self <= other

returns self - other

returns self modulo other

returns self * other

returns self + other

Iteration

Convert self as a Real

Numeric value in string format

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
Raises IteratorIsOff exception in case the iterator is on the last element

Iterator to be used with Collection
See also Collection<G>.getIterator()
@

raised when two objects are not comparable
@

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

@

Adds element in the OrderedCollection at rank index
Raises IndexOutOfBound exception if provided index is lower than 0 or
larger than the size of the OrderedCollection

Returns the element at rank index in the OrderedCollection
Raises IndexOutOfBound exception if provided index is lower than 0 or
larger than the size of the OrderedCollection

Overrides Object.equals(Object)
Returns a Boolean stating whether the provided element is equal to
current OrderedCollection

Returns the first element in the OrderedCollection
Raises an EmptyCollection exception if the OrderedCollection is empty

Returns the index of the first instance of element in the OrderedCollection
or -1 if the element is not contained by the OrderedCollection
Raises an EmptyCollection exception if the OrderedCollection is empty

Returns the last element in the OrderedCollection
Raises an EmptyCollection exception if the OrderedCollection is empty

Removes the element at rank index from the OrderedCollection
Raises IndexOutOfBound exception if provided index is lower than 0 or
larger than the size of the OrderedCollection

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

See Set<G>.add(G)

Overrides OrderedCollection<G>.addAt(Integer, G)
Adds element in the OrderedSet at rank index if the ordered set does
not already contain the element, does nothing otherwise

Builds and returns a new OrderedSet from current one with element
inserted in head

Returns element at rank index in the sequence
Raises IndexOutOfBound exception if provided index is lower than 0 or
larger than the size of the OrderedSet

See OrderedCollection<G>.equals(Object)

Builds and returns a new OrderedSet from current one with element
inserted at rank index

Builds and returns a new OrderedSet from current one with element
inserted in tail

Builds and returns a new OrderedSet composed of elements of current ordered
set from rank min to rank max (order is respected)
Raises IndexOutOfBound exception if min is negative, max is larger than
the size of the ordered set or min is larger than max

An OrderedSet is a Set that contained ordered distinct elements
@

Comparison

returns self / other

Returns true if other type is Integer or Real
and has the same numeric value than current object.

returns self - other

returns self * other

returns self + other

Convert self as an Integer

Returns numeric value in string format

returns -self

class Real
@

Builds and returns a new Sequence from current one with element
inserted in head

Returns element at rank index in the sequence
Raises IndexOutOfBound exception if provided index is lower than 0 or
larger than the size of the Sequence

Overrides OrderedCollection<G>.equals(Object)
Returns a Boolean stating whether the provided element is equal to
current Sequence

Builds and returns a new Sequence from current one with element
inserted at rank index

Builds and returns a new Sequence from current one with element
inserted in tail

Builds and returns a new Sequence composed of elements of current sequence
from rank min to rank max (order is respected)
Raises IndexOutOfBound exception if min is negative, max is larger than
the size of the sequence or min is larger than max

A Sequence is an OrderedCollection of elements allowing duplicates
@

Overrides Collection<G>.add(G)
Adds elt to the Set if it is not already contained by the
Set, does nothing otherwise

Overrides Collection<G>.asBag()
Returns a new Bag composed of all elements of current Set

Overrides Collection<G>.asOrderedSet()
Returns a new OrderedSet that contains all elements of current Set

Overrides Collection<G>.asSequence()
Returns a new Sequence composed of all elements of current Set

Overrides Collection<G>.asSet()
Returns a new Set composed of all elements of current Set

Returns a ordered set of the bag elements sorted using the given comparator.
The comparator must return :<ul>
<li>+1 if the second <G> element is greater than the first</li>
<li>0 if the second <G> element equals the first</li>
<li>-1 if the second <G> element is lower than the first</li>

Recursive sort of the given (ordered) set using the given comparator.
The comparator must return :<ul>
<li>+1 if the second <G> element is greater than the first</li>
<li>0 if the second <G> element equals the first</li>
<li>-1 if the second <G> element is lower than the first</li>

Internal concatenation tool for recursive 'quickSort()' method

Overrides Object.equals(Object)
Returns a Boolean stating whether the provided element is equal to
current Set

Returns a new Set which content includes all non-Collection elements
of the current Set, and, for each Collection element of the current
Set, as many elements as the Collection contains
Duplicates are removed

Returns a new Set corresponding to the intersection of the Set elements
with the current Set

Returns a new Set corresponding to the difference between the
current Set and the Set elements, ie all elements contained by
the current Set that do not appear in the elements Set

Overrides Collection<G>.remove(G)
Removes the element from the Set if it is contained by the Set

Returns a new Set which contents corresponds to the symmetric
difference between current Set and Set s, ie all elements of
each Set that do not appear in the other one

Returns a new Set corresponding to the union of the Set elements
with the current Set

Returns a new Bag corresponding to the union of the Bag elements
with the current Set

A Set is a non-ordered collection that contains distinct elements
(with regards to the G.equals(Object) operation)
@

Appends other at the end of self
A more efficient method is kermeta::utils::StringBuffer::append(other)

Comparaison

Return if a string is contained by another string

returns the character at index in the String

Returns true if other type is String
and has the same string value than current object.

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

returns a new string self + other

Replaces all occurences of str1 in the current string by the string str2

returns the number of characters in the current String

Return of an ordered set of the splitted string
Note that the delimiter is a regular expression (as the split operation in java)

returns a new string that is a substring of this string
takes as parameters : the startIndex and endIndex

Parses the current string and returns true if the string is "true" and false if the string is "false"
The parsing is not case sensitive and if no boolean value is recognized then a StringFormatException is raised.

Parses the current string into an integer.
if no integer value is recognized then a StringFormatException is raised.

Return the current string in lower case

Parses the current string into a real.
if no real value is recognized then a StringFormatException is raised.

returns the string itself

Return the current string in upper case

The class String
@

Summarization method to be implemented by any summable class.
The parameter must have the same type (or one of its subtypes)
than the current object .

The abstract class Summable defines a set of operation
to sum instances of a class.
Sub-classes only has to implement abstract operation plus.
@

NOT IMPLEMENTED

This special object is used to represent java objects that cannot be concretely 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.
However, any instance of a sub-class of ValueType will be passed by value
instead of by reference for any other objects.
that means that each time you := such object it will call the clone function associated to it (Not implemented yet except for Integer, String and boolean!!!)

@

Returns true

Return true

Returns the String identifier '<void>'

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

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

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

Removes all elements from the Hashtable

Returns a Boolean stating whether a key is present or not in this Hashtable

Returns the value for key 'key' if it exists, otherwise returns Void

Returns an iterator over the Keys of this Hashtable

Returns a set containing the hash keys of this Hashtable

Adds a entry into the Hashtable

Removes the entry with key equals to 'key'

Returns the size of this Hashtable

Returns an iterator over the values of this Hashtable

Returns a collection containing the elements of this Hashtable

An implementation of hashtable
This implementation is for speed optimisation it cannot be serialized.
If your wish to serialize its content you need to copy its content into a classical ecore structure (attribute or references)

@

Gets the element at the top of the stack

Get and remove the element at the top of the stack

Pushes an element into the stack

An implementation of stack

@

Append a given string at the end of this StringBuffer
@param arg0 A string to append at the end of this StringBuffer
@return A reference to this object

Return the length of the StringBuffer
@return length of the StringBuffer

Convert this StringBuffer to String and return its value
@return The string value of this StringBuffer

This class mimic the behavior of the java's StringBuffer class. This enables better performance in long
string concatenation.<br>
Only work on Strings

@

Contains the definition of a Kermeta classes used for compatibility with XMLType.ecore

Kermeta representation of EMF type::QName from XMLType.ecore

@

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

user friendly message build with those informations

Element that is not contained by a resource in the repository

Element that has a reference to the dangling element

Property used to reference the dangling element

class used to gather the information required to make a user friendly report about a dangling element
(see. findDanglingModelElements())
@

Overrides Repository.createResource(String, String)
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

Register the content of the given ecore file into EMF registry
Once registered, EMF will be able to load and save models conformant to this ecore file
Warning: if the NSURI you wish to register is already, registered (either statically or due to a previous call)
it will do nothing. Ie. modification in the ecore file will not be taken into account unless you manually unregister it.

When loading the Resources,
if there are some errors while loading some objects, the loader can try to ignore them
setting this attribute to true is equivalent to setting ignoreLoadErrorUnknownMetaclass and ignoreLoadErrorUnknownProperty to true
by default, not setting this attribute is considered as false.

When loading the Resources,
if there are some errors due to an unknown metaclass while loading some objects, the loader try to ignore them
by default, not setting this attribute is considered as false.

When loading the Resources,
if there are some errors due to an unknown property while loading some objects (ie. the metaclass is known but it cannot retreive
the given reference or attribute in the ClassDefinition, the loader try to ignore them
by default, not setting this attribute is considered as false.

If true, tells to the save of the resources that they should also integrate the resources from Kermeta interpreter itself
this is useful 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
@

Overrides Set<Object>.add(Object)
Add an instance to the Resource
Ensures that the instance is referenced by a one and only one Resource of the same Repository
Ensures that the instance does not appear more than once in the Resource

Overrides Resource.load()
In case the metamodelURI was not previously set, metamodelURI is filled with
the nsuri of the root package of the metamodel used to load the Resource after
a successful load

Overrides Set<Object>.remove(Object)
Remove the instance from the Resource

Overrides Resource.save()

Checks the Resource using the EMF validation function, and saves it if
validation succeeds
Applies validation to all root objects of the Resource
Returns true if the validation reports no error, raises exceptions otherwise

Overrides Resource.saveWithNewURI(String)

@
Extension of the Resource class definition that is specific to EMF Repository.
User is not supposed to directly create it. Otherwise it will not be correctly initialized
You must To create one
@

Creates a new Resource with given uri, and an optional mm_uri
mm_uri is required when creating a new model from scratch.
Raises a ResourceCreate exception in case the Repository already
contains a Resource with the given uri
If uri does not points to an existing model file (in the case of
a model creation), calls to load() operation will fail as long as
the model has not been saved once

Search for elements referenced by one element contained by this repository that are not contained by this repository
ie. element that EMF would claim as "not contained in a resource"
example of use :
var report : Set<DanglingDiagnostic>
report := repository.findDanglingModelElements()
report.each{ diag | stdio.writeln(diag.toString ) }

Returns the Resource associated with the given uri if this uri is associated with
an already created Resource of the Repository.
If the Repository contains no Resource associated with the given uri, creates
a new Resource and loads it.
In order to prevent multiple load of the same file by using variant path to the same file, all URI used by this function are normalized
Raises a ResourceCreate exception if the given uri does not point to an existing
model file
May also raises loading exceptions if this is the first retrieval of the resource

Return a normalized version of the Uri
in order to prevent several loading of the same file because they have different path that leads to them, kermeta uses normalizedURI
for some of its functions (eg. repository.getResource )
As EMF needs URI of the form platform:/resource or platform:/plugin, kermeta automatically
normalize the uri when loading or saving. This is especially true for file:/ uri or relative uri (./ or / )
If you wish to know what concrete uri is used by kermeta when loading and saving you can use this function
to check how a given uri is normalized by kermeta

Resources created by this Repository
This feature is supposed read only, otherwise it cannot garantee that an element is contained by only
one Resource of a given Repository

Abstract resource container, that contains a list of available loaded resources,
and methods to create or get a resource given an URI.
A repository cannot contain 2 resources which points to the same file (ie. that have the same normalizedURI)
@

Search for elements referenced by one element contained by this resource that are not contained by this repository
ie. element that EMF would claim as "not contained in a resource"
checks only objects directly referenced by the element in this resource, ignores indirectly referenced objects
example of use :
var report : Set<DanglingDiagnostic>
report := resource.findDanglingModelElements()
report.each{ diag | stdio.writeln(diag.toString ) }

The entities contained in the model-instance, that are provided when user loads a resource
instances == rootContents
this is a loop on Resource itself in order to get backward compatibility
@

Loads the Resource, thus making content of the Resource browsable.
Raises a ResourceLoadException in case loaded Resource is empty

Return a normalized version of the Uri of this resource
in order to prevent several loading of the same file because they have different path that leads to them, kermeta uses normalizedURI
for some of its functions (eg. repository.getResource )
As EMF needs URI of the form platform:/resource or platform:/plugin, kermeta automatically
normalize the uri when loading or saving. This is especially true for file:/ uri or relative uri (./ or / )
If you wish to know what concrete uri is used by kermeta when loading and saving you can use this function
to check how a given uri is normalized by kermeta

Save a Resource in the file specified by the current value of uri

Save a Resource in a file referenced by the new uri.
note: this doesn't change the URI of the resource, it is only saved in another place

Returns the set of all Objects directly or indirectly contained by the Resource,
or an empty set if the Resource is empty
implementation note: since this derived property build a set, it guarantees the unicity, as a drawback,
calling this property on large resources will be really slow due to this verification. some user may prefer
to reimplement it using a bag.

Returns the set of Resources the current Resource, which must have been loaded,
depends on, an empty set if current Resource has no dependency

Indicates weither this resource will be updated when saving the repository
This is useful if the repository contains some metamodels that should not be saved.

Note that in the current version, it doesn't ensure that you have not modified its content (using the freeze)
If you modify the elements of such resource, other resource that depend on it will be incorrectly saved

Uri of the meta-model of the Resource to load

Repository used to create the Resource
This feature is supposed read only, otherwise it cannot garantee that an element is contained by only
one Resource of a given Repository

Uri of the Resource 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?

@

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 @

Object on which the constraint was applied to
On Invariant, we can generally consider this object as the faulty Object

constraint that has failed

Common super class for all ConstraintVioloated exceptions @

An invariant isn't satisfied on a given Object @

The post-condition is not satisfied @

The pre-condition is not satisfied @

@

well-known attempt to divide with a zero valued divider @

to be written #########################################
@

Occurs when trying to access element on an empty collection @

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
@

the file has not be found on the underlying system @

an interaction with the underlying system failed @

Raised by the Object::set operation if the type of the
Object to set has an incompatible type.
@

Occurs when trying to access out of bounds elements @

Occurs when calling next() operation while iterator is already
positioned on the last element of a collection
@

Use this exception when you want to forbid the access to an unimplemented operation
and invite to implement it
@

the figure oversteps the capacity of the numeric variable @

Occurs when trying to crate a Resource already existing in the Repository @

Occurs when Resource loading fails for some reasons @

Occurs when Resource saving fails because an object refers to an element which
belongs to the Definition of the currently running program @

Object on which the the saved failed
One can rescue the exception and analyse the structure next to this object,
this can give some clue about the faulty structure

Occurs when Resource saving fails for some reasons @

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

The code that raised the exception

Exception for interpreter exceptions @

to be written #########################################
@

the data overstep the size of the string variable @

Occurs when a cast (Object::asType operation) fails
@

Raised when a resource cannot be loaded or saved because the URI used for
the metamodel is not registered
@

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

one of the required operands is void @

Contains file input/output related classes.


Contains standard input/output related classes.

Reads a text file

Writes a String in a text file

Writes a String in a text file by using a specific encoding

Implementation of simple helpers to read ans write text files

@

Writes the object to error output

Writeln the object to error output

Reads a String from standard input

Writes the object to standard output

Writeln the object to standard output

An implementation of StdIO : standard input/output

@

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

Initializes 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 parsed sucessfuly

Parse errors and type errors

the expression

Formal parameters of the expression (bindings between parameters' names and types)

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)

@

Error message

Kermeta language error in a code written in Kermeta
@

Kermeta error for parsing problems
@

Type errors in a code written in Kermeta
@

Contains the definition of a Kermeta classes used for compatibility with Ecore

Kermeta representation of EMF EFeatureMapEntry
it contains the name of the required feature and the actual value

@