Noyau du langage de modélisation

Le noyau du langage de modélisation est la base de tout autre langage.

La classe Base est la racine de toutes les classes du domaine gaphor. Diagram et Presentation forment la base de tout ce que vous voyez dans un diagramme.

Tous les modèles de données de Gaphor sont générés à partir des fichiers de modèles réels de ce dernier. Cela nous permet de vous fournir de beaux diagrammes du modèle interne de Gaphor.

Le modèle de base avec les classes de présentation

La classe Base

La classe Base fournit des notifications d’événements et s’intègre au référentiel de modèles (connu en interne sous le nom de ElementFactory). Toutes les classes d’un modèle doivent dériver de cette classe. Si un modèle n’indique pas de classe de base pour un élément, il dérivera de Base. Les relations bidirectionnelles sont également possibles, de même que les relations dérivées.

Les protocoles RepositoryProtocol, et EventWatcherProtocol sont importants pour connecter le modèle au référentiel et aux mécanismes de gestion des événements.

La classe Base est le cœur du modèle de données de Gaphor.

class gaphor.core.modeling.Base(id: str | None = None, model: RepositoryProtocol | None = None)

Classe de base pour toutes les classes de données de modèle.

property id: str

Un identifiant (en lecture seule), unique dans le modèle.

property model: RepositoryProtocol

Le modèle propriétaire, génère TypeError si le modèle n’est pas défini.

unlink() → None

Dissocier l’élément.

Toutes les références des éléments sont alors supprimées. Les éléments associés des associations composites sont également dissociés.

Le verrou de déconnexion est activé lors de la séparation des propriétés de l’élément afin d’éviter les problèmes de récursivité.

Gestion des événements

handle(event: object) → None

Propager les événements entrants.

Cela ne fonctionne que si l’élément a été créé par une ElementFactory

watcher(default_handler: Callable[[ElementUpdated], None] | None = None) → EventWatcherProtocol

Créer un nouvel observateur pour cet élément.

Les observateurs fournissent un moyen pratique de recevoir un signal lorsqu’une propriété relative à self a été modifiée.

Pour utiliser un observateur, l’élément doit être créé par une ElementFactory` correctement câblée.

Cet exemple est purement illustratif :

>>> element = Base()
>>> watcher = element.watcher(default_handler=print)
>>> watcher.watch("note")  # Watch for changed on element.note

Chargement et enregistrement

load(name: str, value: str | bool | int | Base | collection[Base]) → None

Charge la valeur dans le nom.

Assurez-vous que la fonction postload() est appelée après le chargement de tous les éléments.

postload() → None

Réparer diverses petites choses.

Cette opération est exécutée après le chargement de tous les éléments.

save(save_func: Callable[[str, str | bool | int | Base | collection[Base]], None]) → None

Sauvegarder l’état en appelant save_func(name, value).

Méthodes de type OCL

isKindOf(class_: type[Base]) → bool

Retourne True si l’objet est une instance de class_.

isTypeOf(other: Base) → bool

Retourne True si l’objet est du même type que other.

La classe Presentation

class gaphor.core.modeling.Presentation(diagram: Diagram, id: Id | None = None)

Un type spécial de Base qui peut être affiché sur un Diagram.

Les instances de présentation ne peuvent appartenir qu’à des diagrammes.

Les sous-types de Presentation doivent implémenter le protocole gaphas.item.Item.

request_update() → None

Marquer cet objet de présentation pour mise à jour.

Les mises à jour sont orchestrées par des diagrammes.

watch(path: str, handler: Callable[[ElementUpdated], None] | None = None) → Self

Observez un certain chemin d’éléments commençant par self.

Le traitement est optionnel et sera par défaut un simple request_update.

Les surveillants doivent être définis dans le constructeur, de sorte qu’ils puissent être enregistrés et désenregistrés en une seule opération.

self.watch("subject.name")

Cette interface est fluide : elle renvoie self.

change_parent(new_parent: Presentation | None) → None

Modifier le parent et mettre à jour la matrice de l’élément afin que l’élément reste visuellement au même endroit.

La classe Diagram

class gaphor.core.modeling.Diagram(id: str | None = None, model: RepositoryProtocol | None = None)

Les diagrammes peuvent contenir des éléments Presentation.

Si les diagrammes doivent être propriétaires, le langage de modélisation (par exemple UML) doit subdiviser Diagram et ajouter des relations et des règles de propriété.

create(type_: type[P], parent: Presentation | None = None, subject: Base | None = None) → P

Créez un nouvel élément de diagramme sur le diagramme.

Il est créé avec un identifiant unique et est attaché à l’élément racine du diagramme. item. Le paramètre de type est la classe d’élément à créer. Le nouvel élément peut également avoir un parent et un sujet facultatifs.

lookup(id: str) → Presentation | None

Recherche d’un élément de présentation par son identifiant.

Retourne une présentation dans ce diagramme ou retourne None.

select(expression: Callable[[Presentation], bool]) → Iterator[Presentation]

select(expression: type[P]) → Iterator[P]

select(expression: None) → Iterator[Presentation]

Renvoie un itérateur de tous les éléments de la toile qui correspondent à l’expression.

request_update(item: Item) → None

Planifier la mise à jour d’un élément.

Aucune mise à jour n’est effectuée à ce stade, l’élément est seulement ajouté à l’ensemble des éléments à mettre à jour.

Cette méthode fait partie du protocole gaphas.model.Model.

update(dirty_items: Collection[Presentation] = ()) → None

Mettre à jour le diagramme.

Tous les éléments ayant demandé une mise à jour via request_update() sont désormais considérés comme des mises à jour. Si un élément possède une méthode update(context: UpdateContext), elle est invoquée. Les contraintes sont résolues.

Protocoles

class gaphor.core.modeling.base.RepositoryProtocol(*args, **kwargs)

create(type: type[T]) → T

Créer un nouvel élément dans le référentiel.

select(self, expression: Callable[[Base], bool]) → Iterator[Base]

Sélectionner dans le dépôt les éléments qui répondent à l”expression.

select(self, type_: type[T]) → Iterator[T]

Sélectionner tous les éléments du dépôt de type type_.

select(self, expression: None) → Iterator[Base]

Sélectionner tous les éléments du dépôt.

lookup(id: str) → Base | None

Récupérer un élément par son identifiant dans le dépôt.

Renvoie None si aucun élément de ce type n’existe.

class gaphor.core.modeling.base.EventWatcherProtocol(*args, **kwargs)

watch(path: str, handler: Callable[[ElementUpdated], None] | None = None) → EventWatcherProtocol

Ajouter une veille pour un chemin spécifique. Le chemin est relatif à l’élément qui a créé l’objet de surveillance.

Renvoie self, afin que les opérations de surveillance puissent être enchaînées.

unsubscribe_all() → None

Doit être appelé avant que l’observateur ne soit éliminé, pour libérer tous les chemins observés.