| Object |
| Information |
It provides features shared by all objects. |
| Properties |
| Nature |
The unmutable nature of the Object 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 Object 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. |
|
|
|
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 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. |
| 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 instance.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\ll\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. |
|