first meta-model – ISA\\Model\Nominals

Parent
LL
Data
Model
Aliases M1
Information This provides the common Classifiers of LL usable at run-time.
data
Edition
Version 1
Country None.
Language  None.
Tirage  1
Dependencies None.
Inhibit all invariants False.
Scope Ideas.
Diagram
Classes
Bounded
Information A Bounded defines limits to an Ordered
set.
Bounded
Codification
Information A Codification is a that associate a
Code together with a Label.
For instance the standard ISO 3166-1 alpha-2 associate a code
on 2 positions (ex: FR) to a country name (ex: France).
The code is often stable. However, it is not impossible for it to
changes over the time. The only real stable designation mechanism of
an entity is the id property of the Identifier
of the Codification . The
code or label variations resulting in a modification of the 
version.
Properties
Code The code.
Label The label associated to this code (in the language of the
).
Constructor
Codification(◈) Base constructor.
Codification
Enumeration
Information It is the root of the sequence hierarchy. Every enumeration
inherits from Enumeration.
Attribute
Position The significant position of the Enumeration
instance in the Literal names.
Index The index position of the Enumeration
instance in the Literal names.
Constructor
Enumeration (◈)
  Base constructor building any derived type from
a literal name.
Enumeration (Position: Position)
 Construct an Enumeration from a
position.
Routine
Shared
Hash code
 The private method computing the Value. This
method ensures that the Value follows the defined
order in Literal names.
Enumeration
Information It is the root of the hierarchy. Every interfaces
inherits from .This type has these
specificities:
  • It is always abstract.
  • It has only Exposable abstract members,
    expect those inherited from Type.
  • It doesn't have Shared members.
Note
Kind Explanation
Text For interfaces, the Nature property is never
accessible because the Type instance
implementing it is always more concrete and therefore have a
stronger Nature.
This doesn't means that an has not a Nature,
but just that it can never be acceded.
Think for instance to an anonymous type implementing an
, in this case the Nature of this
anonymous type instance will be this interface type. This
justifies that Interface inherits from Type.
NB: In ISA the concept of anonymous type does not exists,
because it is considered to be a construction making the
code unclear.
To go further, if we suppose this kind of anonymous type was
supported in ISA, what Nature would has an
anonymous implementing 2 or more
interfaces? This is also a more formal reason why to not
support this kind of modeling.
Interface
Named
Information This interface is about types that have a name usable in the LL
context.
Property
Name The name of the entity.
Invariants
Name is mandatory and must be valued significantly
The name should have at least 3 not blank characters. It
must begin by a letter.
While the Name property multiplicity is [1..1],
the mandatory constraint is needed for implementing classes
having a parent with a Name having a
multiplicity of [0..1].

 

Name cannot contain LL punctuation nor special characters
The name could be used in the LL language and must not be
confused with language punctuation characters. This is also
applicable for conventional special characters like $.
Named
Nominal
Information It is the root of the nomenclature hierarchy. Every nominal
inherits from Nominal.
Property
Shared
Literal names
 The string array of names of the literals.
Attribute
Name The literal name of this instance.
$ Allows to get the value and to set the nominal value from
another Nominal.
Constructor
Nominal (◈)
  Base constructor building any derived type from
a literal name.
Routine
Shared
Hash code
 The private method computing the Value
Invariant
Name
The Name attribute maps to one of the Literal
names
Information  Ensure the consistency of the Nomenclature
Value
Name
The Name attribute maps to the Value
Information   Ensure the consistency of the Nominal
Name
Nominal
Number
Information It is the root of the number hierarchy. Every numbers
inherits from Number.
Property
String A canonical String representation of the
Number. The conversion constructors are
typically implemented using this representation.
Number
Information It provides features shared by all objects.
Properties
: Identifier The identifier of the .
The volatile objects doesn't require a fully featured Identifier
as persistence is not a concerns for them . They just need
to identified by a pointer.
However, the respect of the Identity
axiom leads to have an Identifier,
but it is completely generated dynamically without any link
to storage.
The persisted objects have a fully featured Identifier.
This Identifier is also instantiated dynamically at run time
when requested (lazy loading).
Inheritances The list of the static and dynamic inheritance links this
Object have with Classifiers.
Hash code The default implementation is the memory address of its Smart
Pointer because it is stable at run time.
Note
Note kind Explanation
Text The memory address of the Object is not
taken into account because it is unstable
while the Object may be relocated in the
memory space. If this occurs, the
associative tables where the Object is
already referenced  will point to an
older position.
A solution could had been to implement a
hash of the of
the Object without its
unstable fields like Object
version. But if the Operation System
warranty that the Smart Pointer address
never changes, its address can be used
securely.
Queries
⊥ Indicates if the Operand can be accurately
compared about Equality against
the current Type in the scope of a given Metamodel
Type and Tag.
= Compare the equality of the current Type
against the Operand in the scope of a given Metamodel
Type and Tag.
Serialize  Serialize the Object as an LL Initializer.
Commands
+ Add dynamically a inheritance to
the Object. This results in adding a classification
relationship occurrence.
– Remove dynamically a inheritance
from the Object. This results in removing a classification
relationship occurrence.
Destructor
Delete() Delete the object and its embedded members, what consists
mainly in freeing the occupied memory.
Notes
Kind Explanation
Text As LL supports real multiple inheritance, a Model
Type instance may have several Metamodel
Types. This is why the Property
Inheritance return 1 or several ISA\LL\Metamodel\Type\.
This is also the reason of the ⊥ and the = operations
have an optional ISA\LL\Metamodel\Type\ argument:
to specify againts wich Type these
operations are to apply. The Tag argument is for
deambiguation in the case of peer inheritance. The
argument is optional for case where the Type
is unique.
An important remark could be made here. As LL integrates the
Metamodel and the Model
in a strong manner, the Metamodel types
are just arguments like others. This means that a unique
parameter passing mechanism is used in all cases, for both Model
and Metamodel Types. This widely make
useless the need to have a distinct way to parametrize Operation
and Class: In other words, having
genericity in LL is not needed.
This way is also more powerful because any kind of Metaclass
can be an argument, not just a Type or a Class.
Moreover the standard arguments mechanisms applies, like
preconditions and postconditions.
Object
Ordered
Information Interface of classes having an full order relationship.
Queries
Declares the order comparison operators.
Ordered
Ordered single
Information A Single with an ordering relationship based on
the Value as a signed integer.
Queries
Defines the order comparison operators.
Ordered single
Root
Information The Root Type is the empty Type,
also defined as the Type in Type
theory (even if in our type system, this Type is
put a root instead of being connected to all inheritance ends).
It is a more formal representation of the null
notion often present in languages.
Since it doesn't have any member (except for its ), any call
on it results in nothing. This is the justification of why
nothing appends when a call is done on an optional argument that is
not valuated. In fact the argument is valuated with the unique
instance of Root. When encountered as the result
of all evaluation paths of an expression, this type is propagated.
This is why this class is not abstract.
This instance is an absolute singleton.
While it is present in the LL run time, it cannot be referenced
explicitly by programs.
Property
Is root type (aliases: Missing, Empty, Void)
 Always return true.
Root
Single
Information A Single value on 64 bits.
A Single materialize the Valuable
metaclass, meaning that it is only identified by its
value.
Property
Hash code The hash code of a Single is its Value.
Field
Value The value
Queries
⊥ Overrides the Type query. True if
the Types are the same.
= Overrides the Type query. True if type
is compatible and the Values are equal.
Single
Type
Information The Type is the most basic not empty Type.
It is featured with the simplest operations, and in particular it is
the support of the Equality type.
Property
Is root type Overrides the Root property. Always
return false.
Nature The unmutable nature of the Type.
Hash code A hash code is an Integer that is used
to identify at run
time a Type in an associative
table (like a hash table).
Two Types that are equal must have a same
hash code. However, the reverse is not true: equal hash
codes do not imply object equality, because different
(unequal) objects can have identical hash codes.
Warning: On
Objects the property is
the only stable identifier along their life cycle.
Queries
⊥ Indicates if the Operand can be accurately
compared about Equality against
the current Type instance.
This capability is evaluated against a certain Type
Classification. By default, the Classification
is the Nature of the Type.
= Compare the equality of the current Type
against the Operand.This comparison is performed
for a certain Type Classification.
By default, the Classification is
the Nature of the Type.
≠ The negation of the equality
operation.
Sight(Features : Feature [0..∞]) : String An overview of the instance as a LL expression.
The Feature are those of this Type instance.
In other words, the Features come from the
attribute Unshared members of the
ISA\LL\Metamodel\Types\AbstractDataType
instance for this Type.
For Object instance having several classifications,
the whole list of Unshared members of theses Classes
are to take into account.
If no Features is provided, all Fields,
Properties and Attributes
are incorporated in the result string except optional empty
ones.
Invariant
The property Is root type is not alterable
This ensure all type to be effective, except the Root
type.
Type
Assemblies

Version and status

Version Date Description Status
V1R1 29-Dec-17 Initial. Candidate

 

Related posts:

  1. Model Assembly
  2. Event Assembly
  3. Relationships Assembly
  4. Containment Assembly
  5. Identity Assembly
Tags: 64 bits, Assembly, Axiom, Class, Genericity, Identity, Instance, Interface, LL, Model, Object, Scope, Universe

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.