first meta-model – ISA\\Model

Parent
LL
Data
Model
Aliases M1
Information This assembly provides the common Classifiers of usable at run-time.
Assembly data
Edition
Version 1
Country None.
Language  None.
Tirage  1
Dependencies None.
Inhibit all invariants False.
Ideas.
Diagram

 

Classes
Bounded
Information A Bounded defines limits to an Orderedset.
Bounded
Codification
Information A Codification is a class that associate aCode together with a Label.For the standard ISO 3166-1 alpha-2 associate a codeon 2 positions (ex: FR) to a country name (ex: France).The code is often stable. However, it is not impossible for it tochanges over the time. The only real stable designation mechanism ofan entity is the id property of the Identifierof the Codification . Thecode or label variations resulting in a modification of the Objectversion.
Properties
Code The code.
Label The label associated to this code (in the language of theAssembly).
Constructor
Codification(◈) Base constructor.
Codification
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 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 to an anonymous type implementing an , in this case the Nature of this anonymous type 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 class implementing 2 or more interfaces? This is also a more formal reason why to not support this kind of modeling.
Interface
Number
Information It is the root of the number hierarchy. Every numbersinherits from Number.
Property
String A canonical String representation of theNumber. The conversion constructors aretypically implemented using this representation.
Number
Information It provides features shared by all objects.
Properties
Nature The unmutable nature of the Type.

It allows to provide a simple way to support its storing, by having a storage unit per Nature on a Node. The other Classifications of the are just indexes that point to this storage unit.
Identity: Identifier The identifier of the Object.

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 Identity of the Object without its unstable fields like Object version. But if the Operating System warranty that the Smart Pointer address never changes, its address can be used securely.
Owned access rights : Access right [1..32] The access rights owned by this Object.

These rights are always provided and acquired thru Operating System operations.

Access rights are limited up to 32 to preserve memory space allocated per object. Using a hierarchical rights management should not make this limit be a very constraining.

TODO: The Access rights part design is not done and is subject to evolve.
Required access rights : Access right [1..32] The access rights required to be able to use this Object.

Access rights are limited up to 32 to preserve memory space allocated per object. Using a hierarchical rights management should not make this limit be a very constraining.

TODO: The Access rights part design is not done and is subject to evolve.
Modified: Boolean TODO CHANGE THAT AND EXPLAIN THE INTERNAL OBJECT IN MEMORY REPRESENTATION

A property that indicates if the Object was modified since its last persistence transaction.  It is set to true when a Command or an Attribute  set results in an field update. It also occurs when a navigable Relationship is updated.

Kind Explanation
Text This property is supported by a bit in the Object register.
Subscriptions
 The list of observer  Subscription the Object have to notify.

The number of Subscription is limited to 10 to save Object memory space. This number should be sufficient for almost all needs. If not, it is possible to have intermediates objects to multiply the possible subscribers (with 2 levels this give 10 x 10 = 100 subscribers, with 3 levels 1000 subscribers).

Kind Explanation
Text This property is the subject of a bit in the Object register to signal the presence / absence of this array in the object memory space. This is for saving object memory space because most objects don't have any subscription.
However, this policy means that the first time a subscription is done the Object have to reallocated.
Queries
⊥ Indicates if the Operand can be accurately compared about Equality against the current Type in the of a given Metamodel Type and Tag.
= Compare the equality of the current Type against the Operand in the of a given Metamodel Type and Tag.
Serialize  Serialize the Object as an Initializer.
Subscribe(Observer: Object, Events: Event class [1..∞], Filter: Condition [0..1], View: View [0..1], Renewable lease: Time [0..1] = 00:01:00) Subscribe to events that can occurs on this Object during its life. This implementation of the Observer Design Pattern allows any Object to subscribe to events on any Object.
Of course, the Observer must have the appropriate access right on the Observed to subscribe.The implementation of the messages exchanges is completely supported by ISA, and this that the Observer and the Observed reside on the same Node or on distinct ones. The mechanism can be seen as chaining a Topic and a Queue in the JMS world.Note that the Subscribe processing is completely delegated to the ISA architecture in order to be not intrusive in the Observed Object. This is why this query is final. This also ensure stability, scalability and reliability.The Subscribe operation is a Query to ensure it doesn't alter the Observed Object state.
Again about decoupling and encapsulation concerns, the veto mechanism is not supported because it is intrusive in the Object behavior and therefore violates encapsulation. The alternative to that is for the Object to ask for the permission before doing the thing that require this permission.The Filter argument allows to filter the event to send. The specific characters \ and $ can be used in this conditional expression respectively to references the Observed Object and the Event class .The View allows to specify a particular set of Features of the Observed Object to provides to the Observer. The Renewable lease argument is a way to be preserved of resource leaks. This is done thru the Access right named ISA\\Model\Object\Maximum subscription lease.
If the Event class named Near of subscription expiration is requested, a notification is send when 80% of the lease is consumed.

TODO: The Event part design is not done and is subject to evolve.
Unsubscribe(Observer: Object) Resign to the subscription.
Commands
+(Added class constructor call: Call, Tag: String [0..1]) Add dynamically a Class inheritance to the Object. This results in adding a classification relationship occurrence.

The Tag allows to distinguish the inheritance paths when inheriting several times of the same class but for different reasons. This feature is called Peer inheritance.
-(Removed class: Class, Tag: String [0..1]) Remove dynamically a Class inheritance from the Object. This results in removing a classification relationship occurrence.
Notify(Event: Event) The notification of an Event the Object has subscribed to.  This notification may alter the Observer this is why it is a command.
Destructor
Delete() Delete the object and its embedded members, what consistsmainly in freeing the occupied memory.
Invariant
Nature = Identifier Nature
The Nature propriety is always aligned with the Nature property of its Identifier.
Notes
Kind Explanation
Text As LL supports real multiple inheritance, a ModelType instance may have several MetamodelTypes. This is why the PropertyInheritance return 1 or several ISA\LL\Metamodel\Type\.This is also the reason of the ⊥ and the = operationshave an optional ISA\LL\Metamodel\Type\ argument:to specify againts wich Type theseoperations are to apply. The Tag argument is fordeambiguation in the case of peer inheritance. Theargument is optional for case where the Typeis unique.An important remark could be made here. As LL integrates theMetamodel and the Modelin a strong manner, the Metamodel typesare just arguments like others. This means that a uniqueparameter passing mechanism is used in all cases, for both Modeland Metamodel Types. This widely makeuseless the need to have a distinct way to parametrize Operationand Class: In other words, havinggenericity in LL is not needed.This way is also more powerful because any kind of Metaclasscan be an argument, not just a Type or a Class.Moreover the standard arguments mechanisms applies, likepreconditions 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 onthe 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 identity), 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 .A Single materialize the Valuablemetaclass, meaning that it is only identified by itsvalue.
Property
Hash code The hash code of a Single is its Value.
Field
Value The value
Queries
⊥ Overrides the Type query. True ifthe Types are the same.
= Overrides the Type query. True if typeis 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 runtime 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 Identity 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

Error

Event

Nominals

Zones

Version and status

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

 

Related posts:

  1. Identity Assembly
  2. Elements Assembly
  3. Relationships Assembly
  4. Containment Assembly
  5. Nominals (Model) Assembly
Tags: 64 bits, Assembly, Axiom, Class, Encapsulation, Genericity, Identity, Instance, Interface, LL, Model, Object, Scope, State, Universe, View

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.