CA2192049C - Procede de manipulation de modeles de donnees utilises en genie logiciel - Google Patents

Abstract

La présente invention concerne un procédé de manipulation de modèles dedonnées pour le transfert de modèles entre une pluralité d'outils (Ta, Tb, Tc, Td,...) de génie logiciel et pour l'application à un modèle, de règles de transformation, la transformation de modèles de données étant réalisée au moyen de passerelles (Ba, Bb, Bc, Bd, ...) permettant de convertir le format d'un outil dans le format d'un autre outil en passant par un format intermédiaire neutre et unique (NIM). Le présent procédé est remarquable en ce que l'élaboration des passerelles est, selon une approche dite orientée objet, réalisée à partir d'un langage exécuté, les passerelles étant des exécutables permettant la transformation d'un modèle de données en plusieurs étapes activées successivement, de manière systématique ou conditionnelle, grâce à un langage de commande décrivant une logique d'enchaînement dynamique des étapes, l'enchaînement étant une procédure paramétrée et nommée. Chaque étape est un exécutable dont le code est développé à partir d'un ensemble de classes réutilisables alors que l'activation d'une procédure nécessite simplement de fournir le nom et les paramètres de la procédure correspondante.

Description

2192q~9 Procédé de manipulation de modèles de données utilisés en génie logiciel.

La présente invention concerne un procédé de manipulation de modèles de données pour le transfert desdits modèles entre une pluralité d'outils de génie s logiciel et l'application à un dit modèle, de règles de transformation, la transformation de modèles de données étant réalisée au moyen de passerelles permettant de convertir le format d'un outil dans le format d'un autre outil en passant par un format intermédiaire neutre et unique.

10 De manière générale, la volonté commune et profonde des utilisateurs ou des concepteurs est de rechercher l'interopérabilité entre outils logiciels pour permettre d'échanger, sous forme de modèles de données, des informations relatives au développement d'applications entre des outils de développement hétérogènes utilisés dans leur environnement propre. En particulier, le transfert 15 de modèles de données peut être d'une aide précieuse pour permettre par exemple, la migration d'applications entre outils de génie logiciel ou entre un outil de génie logiciel existant et un nouvel outil de développement d'un modèleclient/serveur, ou bien la gestion d'informations de développement, sous forme de modèles de données, par exemple dans un référentiel (appelé "repository"
20 par l'homme de métier). Ainsi, et ceci sachant que l'utilisation de tels outils est de plus en plus courante, il peut être désiré administrer, récupérer ou transférer des fichiers d'export d'un ou vers un ou plusieurs outils de génie logiciel du marché permettant de faire de la conception ou de l'analyse de modèles - d'information. Cependant, dans l'état actuel des choses, divers inconvénients 2s sont présentés. En effet, chaque outil a son propre formalisme interne et unemanière privée ou spécifique de représenter les objets, de stocker les informations, etc, si bien que deux outils ne peuvent communiquer ou s'échanger directement des informations.

30 La solution qui était encore récemment utilisée, pour passer outre ces inconvénients, consistait à développer pour chaque outil et d'outil à outil, ce que l'homme du métier appelle des "passerelles" c'est-à-dire des interfaces dont le rôle est de permettre de convertir le format d'un outil dans le format d'un autre outil. De la sorte, pour autoriser le dialogue entre outils, il devait être développé
35 pour chaque outil un nombre de passerelles égal au nombre d'outils avec lesquels il était désiré communiquer et lorsqu'un nouvel outil apparaissait il était nécessaire de développer pour chaque outil une passerelle spécifique pour autoriser le dialogue avec le nouvel outil. A l'évidence, cette solution présente un inconvénient principal qui est qu'elle nécessite de créer autant de passerelles qu'il y a de combinaisons d'outils possibles, ce qui en terme de coût et de temps de développement devient très rapidement prohibitif. En effet, à titre d'exempleet ceci même en prenant un nombre d'outils relativement restreint, pour 5 permettre le dialogue entre, respectivement, 4, 5 ou 6 outils, il faudrait nécessairement développer, respectivement, 6, 10 ou 15 passerelles.

Pour remédier au moins partiellement à cet inconvénient, certains ont imaginé
une solution qui consistait à développer des passerelles également spécifiques 10 mais prévues pour permettre de convertir le format d'un outil dans le format d'un autre outil en passant par un format intermédiaire commun neutre et donc unique en créant un modèle d'information pivot neutre servant de noyau d'échange.
Cette notion de représentation neutre utilisant ce modèle d'information pivot, où
toutes les passerelles passent par ce noyau d'échange, permet de réduire 15 significativement le nombre de passerelles et ceci d'autant plus que le nombre d'outils à mettre en communication est grand. Ainsi, en reprenant l'exemple précédent, pour permettre le dialogue, entre, respectivement, 4, 5 ou 6 outils, il sera dans ce cas nécessaire de ne développer que, respectivement, 4, 5 ou 6 passerelles, une passerelle par outil pour accéder audit noyau d'échange et 20 convertir le format dudit outil dans le format intermédiaire commun. Avec ce type de solution, pour assurer une portabilité aisée, il a été opté pour une approchepropriétaire dans laquelle sont développés des langages spécifiques, donc écritset interprétés pour remplir cette fonctionnalité, qui sont compacts, de contrôlefacile et fonctionnellement adaptés. En effet, dans ce monde fermé le portage 25 est assez significativement simplifié puisqu'un seul programme est à interpréter.
Cependant, cette solution bien qu'avantageuse comporte également des inconvénients. Un premier inconvénient est inhérent au fait qu'un langage interprété est assez peu rapide, I'interprète devant analyser ledit langage pourpouvoir ensuite effectuer les actions décrites. Un second important inconvénient30 à utiliser un tel langage propriétaire est qu'il ne permet pas d'exploiter la notion de composant réutilisable. En effet, lorsqu'il est désiré développer une nouvelle passerelle, il est nécessaire de réécrire tout le code dans ce langage spécifique.
Par ailleurs, de tels langages souffrent généralement d'un environnement de développement très pauvre (pas de bibliothèques de fonctions réutilisables, pas 35 d'outil de mise au point ou "débogueur", etc.).

La présente invention a pour but de remedier aux divers inconvénients des différentes méthodes de l'art antérieur connues et propose un procédé de 2192~49 manipulation de modèles de données qui, de par le choix judicieux du langage utilisé apporte une importante flexibilité et une grande rapidité d"exécution, est aisément extensible et permet d'exploiter la notion de composant réutilisable tout en offrant un haut niveau de portabilité et de performances ainsi qu'un faible s coût.

Pour cela, le procédé de manipulation de modèles de données mentionné dans le préambule est remarquable en ce que, I'élaboration des passerelles est, selonune approche dite orientée objet, réalisée à partir d'un langage exécuté, les 10 passerelles étant des exécutables permettant la transformation d'un modèle dedonnées en plusieurs étapes activées successivement, de manière systématique ou conditionnelle, grâce à un langage de commande décrivant une logique d'enchaînement dynamique des étapes, I'enchaînement étant une procédure paramétrée et nommée, chaque étape étant un exécutable dont le code est 15 développé à partir d'un ensemble de classes réutilisables et l'activation d'une procédure nécessitant simplement de fournir le nom et les paramètres de ia procédure correspondante.

Ainsi, selon l'idée de l'invention, il a été décidé d'utiliser un langage exécuté en 20 adoptant une approche orientée objet et ceci malgré un préjugé défavorable, les langages propriétaires développés de manière spécifique étant considérés autoriser une portabilité aisée et favoriser une stricte adaptation fonctionnelle ressentie comme nécessaire. Contrairement à ce préjugé et donc aux approches antérieures connues, il a donc été décidé d'utiliser un langage standard connu 2s plus flexible, de préférence directement compilé et dont la gestion mémoire est plus fine et plus efficace, par exemple comme le langage C++. En outre, un tel langage présente un très bon niveau d'abstraction et, employé avec des bibliothèques adéquates, il permet d'une part, d'augmenter l'efficacité et la rapidité et d'autre part, d'apporter une avantageuse généricité puisqu'une même 30 structure peut être réutilisée dans des contextes différents, les facteurs deréutilisabilité et de compatibilité étant ainsi de plus favorisés. Autre avantage, ce type de langage peut être aisément mis au point à l'aide d'un débogueur correspondant, ce qui permet de diminuer encore les temps de développement des passerelles. Enfin, un tel choix d'un langage standard pour lequel il existe de 35 très nombreux produits et utilisateurs ne peut qu'offrir l'assurance d'un environnement de qualité.

2192Q~9 De cette manière, pour réaliser des transferts d'un outil à un autre ou d'un modèle à un autre, il existe plusieurs composants conçus pour permettre d'exécuter le code d'une passerelle, chaque passerelle étant en fait développée comme un programme orienté objet construit à l'aide de bibliothèques de classes 5 réutilisables. Ces classes vont servir à élaborer différentes passerelles sachant qu'une passerelle peut être construite en plusieurs phases, par exemple, une phase de décodage physique des fichiers par reconnaissance des codes et donc des éléments syntaxiques dans le fichier d'import, puis une phase de codage de la transformation dans laquelle sont trouvés ou créés les correspondants des 10 éléments syntaxiques dans le modèle d'information neutre et éventuellement une phase de contrôle d'intégrité. Chacune de ces phases constitue un module réutilisable et l'ensemble des modules peut être enchaîné dynamiquement non comme un programme mais selon une suite de procédures à appliquer. Pour cela, la liste des modules à enchaîner dynamiquement est décrite à l'aide d'un 15 fichier de définition d'opérations (appelé également "operation definition file" par l'homme du métier), alors qu'un gestionnaire de tâches (appelé aussi 'task manager" par l'homme du métier) va chercher, parmi les exécutables contenant les procédures réutilisables, lesdits modules pour les exécuter et ainsi construire la passerelle en tenant compte des paramètres de configuration pour 20 I'adaptation de ladite passerelle. Toutes ces informations peuvent être stockées dans un espace persistant, par exemple un disque, tandis que les résultats intermédiaires sont gardés temporairement en mémoire. En outre, le gestionnaire de tâches permet également de sélectionner l'ordre d'exécution optimal lorsqu'il existe simultanément plus d'une procédure eVou d'un exécutable2s qui conviennent. En effet, il peut être, par exemple disposé de plusieurs copies de différentes procédures, dans ce cas, le gestionnaire de tâches sélectionne automatiquement la séquence de modules et la classe de procédure qui minimise le chargement des exécutables ce qui permet d'optimiser la durée d'exécution.
Le procédé de manipulation de modèles de données active donc des composants réutilisables qui permettent de développer rapidement des passerelles. De manière remarquable, pour le développement d'une passerelle, il est créé une classe réutilisable permettant de représenter les modèles et méta-35 modèles stockés en mémoire dans un référentiel ou dans un fichier externe enutilisant une allocation dynamique des objets de modélisation, les objets de cette classe intégrant un ensemble de structures de mémoire et fournissant des fonctions pour manipuler les données d'un modèle chargé en mémoire.

21920~9 De manière générale, les données peuvent être stockées sous différentes formes, formats et emplacements. De préférence et de sorte à simplifier les manipulations, les mécanismes suivants sont ici privilégiés:

- un mécanisme permettant de lire, écrire et analyser les fichiers d'export d'outil (ou "tool export file") qui sont des fichiers de données utilisateur générés par un outil dans un format propriétaire, - des mécanismes qui correspondent à des objets, par exemple des objets C++, qui encapsulent ou intègrent chacun un ensemble de structures mémoire et fournissent des fonctions pour manipuler des modèles de données chargés à
partir de fichiers d'export d'outil eVou d'un référentiel, la mise en oeuvre de ces objets et les fonctions de manipulation de ces objets constituant une classe 15 réutilisable. De manière préférée, I'organisation des données d'un modèle estbasée sur un métamodèle chargé au moment de la création de ces classes, les métamodèles étant chargés au moment de l'exécution à partir de fichiers de textes appelés fichiers de métamodèles. Une telle classe peut être chargée avec un métamodèle d'outil ou peut être chargée avec un métamodèle du modèle 20 d'information neutre, ces deux types d'objets étant utilisés pendant l'exécution de la passerelle, - un mécanisme appelé fichier de données neutre qui est un fichier de texte contenant des données qui ont été mises en correspondance avec des 25 données du modèle d'information neutre, ce mécanisme étant utilisé pour le transfert des données entre différents exécutables ou pour le stockage permanent sue disque, - un référentiel dans lequel les données d'un utilisateur peuvent être 30 stockées en utilisant des schémas représentant le modèle d'information neutre, et être gérées par des outils du référentiel (par exemple, gestion des versions,des requêtes, etc.).

Ainsi, avec les passerelles, les données peuvent être déplacées et manipulées 35 d'un emplacement ou d'un mécanisme de stockage à un autre eVou d'une forme à une autre. Il peut être donné trois exemples de passerelles, les passerelles d'import, d'export ou de transfert. La mise en oeuvre d'une passerelle d'import permet d'extraire des données d'un fichier d'export d'un outil pour les placer - ` 21920~9 dans le référentiel alors que la mise en oeuvre d'une passerelle d'export permetd'extraire des données du référentiel pour créer un fichier d"export d'outil. Lamise en oeuvre d'une passerelle de transfert permet elle de récupérer des données directement d'un fichier d'export d'un outil à un autre sans passer par 5 un stockage dans le référentiel. Il y a bien entendu d'autres types d'opérations dont l'objet n'est pas nécessairement de déplacer ou de coder des données mais qui permettent de traiter des données chargées à un instant donné en mémoire.
Toutes ces opérations requièrent donc la possibilité de charger des données en mémoire, de les manipuler ainsi que d'écrire les données en les stockant de 10 manière persistante, ces opérations étant réalisables du fait de l'existence des classes réutilisables et des fonctions ici revendiquées. Un certain nombre d'opérations requièrent la création d'objets mutiples et impliquent des conversions ou codages entre divers objets. Par exemple, lorsque des données sont extraites d'un fichier d'export d'outil, un exécutable permet d'analyser 15 syntaxiquement ce fichier et de créer un objet qui contient les données du fichier d'export mais structurées de manière à correspondre au métamodèle de l'outil.
Ensuite, les données spécifiques de l'outil sont converties en données généralesselon le modèle d'information neutre qui implique la conversion de cet objet en un objet correspondant au modèle d'information neutre. Les données ainsi 20 stockées peuvent être traitées et éventuellement sauvegardées dans un fichierde données neutre (si les données doivent être communiquées à un autre exécutable) ou stockées dans le référentiel.

Par conséquent, les passerelles permettent d'accéder aux modèles de données 25 et aux définitions de métamodèles stockés en mémoire, les objets des modèles étant dynamiquement alloués en mémoire. Après chargement du métamodèle, un modèle est construit en utilisant le gabarit du métamodèle. Les ensembles de modèles ont une structure similaire à celle des ensembles de métamodèles, ce qui autorise de rapides mises en correspondance entre objets et entre définitions 30 des propriétés et leurs instances.

Egalement de manière caractéristique, pour le développement d'une passerelle, il est créé une classe réutilisable permettant de coder et décoder différents formats de fichiers d'export d'outils, cette classe encapsulant les enregistrements 35 d'export d'outil et étant utilisée pour décrire les formats d'enregistrement d'un fichier d'import, alors qu'à l'initialisation, tandis que le métamodèle d'un outil est lu à l'aide de la classe de représentation des modèles et métamodèles stockés en mémoire à partir d'un fichier de texte, le code de la passerelle permet de lire 21920~9 le fichier d'export d'outil, d'accéder aux champs propres aux enregistrements etde créer les objets et leurs propriétés en utilisant les fonctions de la classe de représentation des modèles et métamodèles stockés en mémoire.

5 En effet, les langages de programmation et donc également le langage C++ ne permettent pas de manipuler de manière directe des structures contenant plusieurs champs variables. La solution proposée ici est de mettre en oeuvre desdéclarations d'enregistrements sous la forme d'une série de descripteurs de champs. Le programmeur définit des tailles de champs fixes et variables, des 10 codes type d'enregistrement avec pour valeurs des constantes et des valeurs de séparateurs. Dans le code traitement, le programmeur appelle d'abord des fonctions permettant de faire correspondre un enregistrement avec son descripteur puis accède aux champs de l'enregistrement. Pour la création d'un enregistrement du fichier d'export, le programmeur remplit les champs propres à
15 cet enregistrement à partir des données du modèle puis il écrit l'enregistrement dans son entier. La description de l'enregistrement comporte, pour chaque champ, le nom, le type et la taille de l'information au moment de l'exécution.
L'information de description de même que les données peuvent être affichées pour la mise au point.
Cette classe ainsi revendiquée permet de définir des macros pour la constructiondes descripteurs d'enregistrement et des prototypes de fonctions pour faire correspondre un registre avec une description d'enregistrement, en fournissant des données à partir d'un champ dans un enregistrement, en fixant des données 25 dans un champ d'enregistrement et en fournissant un enregistrement complet pour l'extraction.

Cette classe réutilisable permet ainsi avantageusement de réaliser différents traitements de différents fichiers d'export d'outil, ces fichiers étant lus et écrits au 30 moyen de composants de la passerelle.

Enfin et également de manière remarquable, pour le développement d'une passerelle, il est créé une classe réutilisable de manipulation de chaînes de caractères qui permet de prendre en charge les affectations, les concaténations 35 et les opérateurs de comparaison avec les fonctions de sous-chaîne et de réaffectation dynamique de mémoire tout en conservant la compatibilité avec les chaînes de caractères d'un langage de type C.

21~20~9 De cette manière, cette classe réutilisable fournit une solution technique pratique en proposant un type de données spécifique des chaînes de caractères qui offre un comportement comparable à celui des types de données prédéfinis en langage C. Cette classe présente aussi une caractéristique de grande 5 importance, car elle permet d'interdire toute perte d'information généralement associée à des pertes de blocs de mémoire.

La description suivante en regard des dessins annexés, le tout donné à titre d'exemple non limitatif, fera bien comprendre comment et dans quel 10 environnement l'invention peut être réalisée.

La figure 1 donne un exemple d'interopérabilité selon la présente invention entre divers outils de génie logiciel.

15 La figure 2 représente une architecture dans laquelle apparaissent divers composants permettant de mettre en oeuvre l'invention.

Sur la figure 1 est présentée de manière schématique et en conformité avec l'idée de l'invention la possible et avantageuse interopérabilité dans un 20 ensemble d'outils Ta, Tb, Tc, Td,..., de génie logiciel, lesdits outils s'échangeant, sous forme de modèles de données, des informations, par exemple, relatives au développement d'applications. Les outils Ta, Tb, Tc et Td sont des outils de développement hétérogènes utilisés, chacun, dans un environnement propre et avec son propre dictionnaire. La transformation de modèles de données entre 25 ces quatre outils est réalisée au moyen de passerelles telles que Ba, Bb, Bc et Bd qui permettent de convertir le format propre d'un des outils Ta, Tb, Tc, Td dans le format propre d'un autre desdits outils en passant par un format intermédiaire neutre et unique, le modèle d'information neutre NIM. Plus précisément, les informations échangées transitent par les fichiers d'export 30 desdits outils qui ainsi transmettent ou recoivent les données vers le ou du modèle NIM qui est par conséquent le modèle pivot. Les données qui instancient le modèle d'information neutre NIM sont stockées dans une base de données objets appelée référentiel.

35 Sur la figure 2 est proposé un exemple d'architecture dans laquelle apparaissent divers composants permettant de mettre en oeuvre l'invention, composants parmi lesquels des interfaces, des contrôleurs, des mécanismes de stockage, des fichiers de configuration, des séquences type de contrôle (scripts dans le ~ g langage exécuté selon l'invention). des passerelles ainsi que le référentiel. Cet environnement peut être considéré comme étant une boîte à outils de développement. Toute action de cette boîte à outils est contrôlée par une classede contrôle CC appelée aussi classe d'interface programmeur, cette classe 5 permet d'organiser l'environnement pour le transfert de données et également d'appeler les procédures adéquates. Les développeurs d'interfaces pour la visualisation sur l'écran d'un poste de travail WS, comme l'interface graphique utilisateur GUI, I'interface de lignes de commande CLI ou tout autre interface, utilisent exclusivement la classe de contrôle CC. Cette classe CC contient les 10 fonctions de l'interface applicative (API) permettant d'appeler les passerelles et de lancer toute commande. Il est ici rappelé d'une part, qu'une passerelle est un mécanisme spécifique pour autoriser le déplacement de données d'un emplacement à un autre et leur manipulation d'une forme à une autre et d'autre part qu'il existe, entre autres, trois types de passerelles, les passerelles d'import, 15 d'export et de transfert. La classe de contrôle CC est paramétrée par les fichiers de configuration CF et les séquences de type contrôle CS (scripts). Les données peuvent être chargées en mémoire sous différentes formes et formats et à des emplacements différents. Quatre mécanismes de stockage peuvent être ainsi utilisés, chacun ayant une utilité propre et possédant son propre jeu de services 20 associés, ce sont les fichiers d'export d'outil TEF, le fichier de données neutre NDF, le référentiel R et un mécanisme D d'allocation dynamique d'objets de modèle. Un fichier d'export d'outil TEF est en fait un fichier de données utilisateur généré par un outil externe dans le format propriétaire dudit outil, ce fichier TEF peut être, selon les moyens de l'invention, lu, écrit et analysé. Un25 fichier de données neutre NDF qui lui est un fichier de texte contenant le résultat de la modélisation, selon le métamodèle d'information neutre, du modèle importé
et initialement structuré selon le métamodèle de l'outil. Ce fichier NDF est unereprésentation ASCII de cette représentation neutre du modèle. Des services de lecture et d'écriture du fichier de données neutre NDF sont fournis selon 30 I'invention. Un fichier de données neutre permet de transférer des données relatives à des objets C++ d'un exécutable à des objets C++ d'un autre exécutable en évitant toute perte de données. Le référentiel R contient, quant àlui, un schéma permettant de mettre en oeuvre le modèle d'information neutre.
Les données d'un utilisateur peuvent être stockées dans le référentiel dans le 35 format du modèle d'information neutre et ensuite gérées et manipulées par desoutils du référentiel incluant la gestion des versions, des requêtes, etc., alors que des services sont fournis pour stocker des données dans ou extraire des données du référentiel. Un fichier de données neutre NDF peut aussi être stocké

dans le référentiel comme un objet avec son contenu. Le mécanisme D
d'allocation dynamique d'objets de modèles est également un point fort de l'invention, il fournit un jeu de classes C++ utilisé pour la représentation de modèles de données de façon totalement générique et dans la manière spécifiée 5 par les données du métamodèle chargées au moment de l'exécution. Un métamodèle est chargé à partir d'un fichier de texte appelé fichier de métamodèle et est stocké comme un objet C++. Les données d'un utilisateur qui sont ensuite stockées comme objets C++, sont mises en correspondance dans le métamodèle associé. Il est à noter que le modèle d'information neutre est un 10 métamodèle prévu pour être suffisament complet pour permettre de capturer la plupart des concepts de tous les métamodèles d'outils. Un objet C++ qui est chargé avec le métamodèle du modèle d'information neutre est en fait un format de stockage central ou pivot à partir duquel peut être généré tout autre format de stockage. Le mécanisme D d'allocation dynamique d'objets contient l'ensemble 15 des classes nécessaires à la mise en oeuvre de l'invention de même qu'il contient tous les métamodèles MTa, MTb,..., NIM MT.

Les quatre mécanismes de stockage, fichiers TEF, fichiers NDF, référentiel R et mécanisme D sont en relation directe avec un mécanisme de passerelles et 20 d'opérations OBM qui est également en relation avec la classe de contrôle CC.
Comme cela a déjà été dit précédemment et de plus en relation avec la figure 2 et en particulier le mécanisme de passerelles et d'opérations OBM, pour réaliserdes transferts d'un outil à un autre ou d'un format à un autre, il existe plusieurs 25 composants conçus pour permettre d'exécuter le code d'une passerelle, chaque passerelle étant en fait une opération développée comme un programme orienté
objet construit à l'aide de bibliothèques de classes réutilisables. Ces classes servent à élaborer différentes passerelles Ba, Bb, Bc, ...,sachant qu'une passerelle peut être construite en plusieurs phases, par exemple, une phase de 30 décodage physique des fichiers par reconnaissance des codes et donc des éléments syntaxiques dans le fichier d'import, puis une phase de codage de la transformation dans laquelle sont trouvés ou créés les correspondants des éléments syntaxiques dans le modèle d'information neutre et éventuellement une phase de contrôle d'intégrité (mécanisme IC). Chacune de ces phases constitue 3s un module réutilisable et l'ensemble des modules peut être enchaîné
dynamiquement non comme un programme mais selon une suite de procédures.
Pour cela, la liste des modules à enchaîner dynamiquement est décrite à l'aide d'un fichier de définition d'opérations ODF (appelé également "operation definition file" par l'homme du métier), fichier exploité par un gestionnaire detâches TM (appelé aussi 'task manager" par l'homme du métier) qui va chercher, parmi les exécutables contenant les procédures réutilisables, lesdits modules pour les exécuter et ainsi construire la passerelle en tenant compte des s paramètres de configuration pour l'adaptation de ladite passerelle tout en autorisant, comme cela a été explicité précédemment, une avantageuse réduction de la durée d'exécution. Tous ces paramètres peuvent être stockés dans un espace persistant (CS), tandis que les résultats intermédiaires sont gardés temporairement en mémoire. Le procédé de manipulation de modèles de 10 données active donc des composants réutilisables qui permettent de développerrapidement des passerelles. Des opérations autres que les passerelles peuvent être effectuées telles que des opérations autonomes ("standalone operations") qui sont des opérations dans lesquelles les données ne sont pas obligatoirement déplacées ou converties, par exemple le contrôle d'intégrité IC ou les services 15 de conversion de nommage NCS.

Pour une meilleure appréhension de l'idée de l'invention, il est proposé ci-après quelques définitions et une description de mises en oeuvre possibles mais non limitatives de diverses classes revendiquées selon la présente invention.
Tout d'abord, il est proposé des définitions de classes relativement à
l'organisation des "scripts" et aux configurations, se rappelant qu'un composantd'une application est un programme qui fournit une interface à un utilisateur del'environnement de l'invention, interface qui peut être de tout type. L'application 25 instancie un objet de la classe de contrôle (TsControl Class) au nom de l'utilisateur, puis appelle ses fonctions pour connaître les opérations permises à
cet utilisateur. L'utilisateur peut soit choisir parmi ces opérations et fournir des informations sur la manière dont lesdites opérations doivent être exécutées soitspécifier des "scripts" de contrôle prédéfinis qui contiennent ces instructions et 30 informations. Lorsque l'application le permet, la classe de contrôle (TsControl Class) peut être également utilisée pour créer ces "scripts" prédéfinis.

La classe de contrôle (TsControl Class) est utilisée pour configurer et initier les opérations dans l'environnement de l'invention. L'application utilise les fonctions 35 pour lire et écrire les "scripts" de contrôle et dresser la liste des opérations possibles. Les valeurs mots-clés peuvent être définies en utilisant les fonctions "set" et "get" et des actions peuvent être commandées en utilisant la fonction "do". Certaines de ces fonctions sont génériques lorsque l'utilisateur spécifie le mot-clé ou l'opération auquel la fonction s'applique, tandis que la plupart des fonctions sont spécifiques de mots-clés ou d'opérations connues. Ces dernières fonctions sont prévues pour être utilisées avec une interface appropriée et le code du composant de l'application.

classe TsControl {

TsSysConfig sysconf; ll Objet fichier de configuration TsMessageLib msglib; //Objet bibliothèque de messages TsOperCtlScript //Script de contrôle ~operctl; ll Pointeurd'objet TsStr opername; IlNom d'opération Singly_linked_list(TsKwdlnfoPtr) ll Liste de mots-clés keywords; ll Doubly_linked_list(TsStr) ll Liste d'outils disponibles ~tools_list; ll int error; ll Valeur d'état d'erreur Il Valeurs mémorisées de mots-clé communs et connus, - TsTokens importfiles; ll Liste de fichiers d'import TsTokens exportfiles; ll Liste de fichiers d'export TsStr srcpctepath; ll Nom d'accès au référentiel (source) TsStr tarpctepath; ll Nom d'accès au référentiel (cible) TsStr srctoolname; ll Nom de l'outil source TsStr tartoolname; ll Nom de l'outil cible TsStr logfilepath; //Nom d'accès au fichierjournal TsBoolean autonaming; ll indicateur de nom normalisé
TsBoolean autochecking; ll Indicateur de contrôle d'intégrité

Il Fonctions internes Doubly_linked_list(TsStr)* ll GetGroupPrompts( ll Lecture de noms de groupes Singly_linked_list(TsGrouplnfoPtr) ll Groupement d'info et retour *group_list ); ll vers le demandeur TsKwdlnfo *FindKeyword( ll Trouver définition de mot-clé
const TsStr& keyword ) const; ll objet pour un mot-clé donné
void AddKeywords(const ll Ajouter mots-clés a la liste 0 Singly_linked_list(TsKwdlnfoPtr)& ll Liste de mots-clés kwd_list ); ll Il Fonctions constructeur et destructeur TsControl( ll Constructeur const TsStr& sys_config_path, ll Chemin du fichier de configuration constTsStr& msg_lib path //Cheminbibliothèquedemessages ); 11 virtual -TsControl(); ll Destructeur 20 ll Fonctions pour le chargement et la génération de "scripts" de contrôle et leurs exécutions int LoadNewOperCtlScript( ll Charger un "script" de contrôle const TsStr& ctl_script_path ); ll int WriteOperCtlScript(); ll Ecrire valeurs dans "script" de contrôle int CreateOperCtlScript( ll Créer un "script" de contrôle const TsStr& ctl_script_path ); ll int RunOperCtlScript(); ll Exécuter"script" de contrôle Il Fonctions pour fixer et lire le nom de l'opération void SetOperationName( ll Fixer le nom de l'opération const TsStr& opname ); ll const TsStr& GetOperationName() const; ll Lire le nom de l'opération s Il Fonctions pour fixer et lire les valeurs de mots-ciés connus void SetTargetPctePath( ll Fixer chemin référentiel (cible) const TsStr& tpath ); ll const TsStr& GetTargetPctePath() const; ll Lire chemin référentiel (cible) void SetSourcePctePath( ll Fixer chemin référentiel (source) const TsStr& spath ); ll const TsStr& GetSourcePctePath() const; ll Lire chemin référentiel (source) void SetTargetToolName( ll Fixer nom de l'outil cible const TsStr& tname ); ll const TsStr& GetTargetToolName() const //Lire nom de l'outil cible void SetSourceToolName( ll Fixer nom de l'outil cible const TsStr& sname ); ll const TsStr& GetSourceToolName() const; ll Lire nom de l'outil source void SetLogFilePath( ll Fixer chemin fichierjournal const TsStr& Ipath ); ll const TsStr& GetLogFilePath() const; ll Lire chemin fichierjournal void SetAutoNamingOn(); ll Enclenche la normalisation des noms void SetAutoNamingOff(); ll Supprime la normalisation des noms void SetAutoNamingFlag( ll Fixer valeur d'indicateur de nom const TsStr& name flag ); ll Chaîne de caractères indicateur int GetAutoNamingState(); ll Lire état indicateur nom const char *const GetAutoNamingFlag(); ll Lire indicateur nom void SetAutoCheckingOn(); ll Indique contrôle d'intégrité
void SetAutoCheckingOff(); ll N'indique pas contrôle d'intégrité

2lgc~o~9 void SetAutoCheckingFlag( ll Fixer valeur indicateur contrôle d'intégrité
const TsStr& check_flag ); ll Indicateur de chaîne de caractères int GetAutoCheckingState(); ll Lire état indicateur contrôle d'intégrité
const char *const GetAutoCheckingFlag(); ll Lire valeur indicateur contrôle d'intégrité
void SetlmportFiles( ll Ajouter noms fichiers import const TsStr& if iles ); ll Chaîne noms fichiers import 0 void AddlmportFile( ll Ajouter nom fichier import const TsStr& if ile ); ll Nom fichier import void RemovelmportFile( ll Annuler nom fichier import const TsStr& ifile ); ll Nom fichier import int IslmportFileOnList( ll Vérifier si nom sur liste const TsStr& ifile ); ll Nom fichier import const TsStr& GetlmportFilesStr(); ll Lire chaîne noms fichiers import const Doubly_linked_list(TsStr)& ll GetlmportFilesList(); ll Lire liste noms fichiers import void SetExportFiles( ll Ajouter nom fichiers export const TsStr& efiles ); ll Chaîne noms fichiers export void AddExportFile( ll Ajouter nom fichier export const TsStr& efile ); ll Nom fichier export void RemoveExportFile( ll Annuler nom fichier export const TsStr& efile ); ll Nom fichier export int IsExportFileOnList( ll Vérifier si nom sur liste const TsStr& efile ); ll Nom fichier export const TsStr& GetExportFilesStr(); ll Lire chaîne noms fichiers export const Doubly_linked list(TsStr)& ll GetExportFilesList(); ll Lire liste noms fichier export const Doubly_linked_list(TsStr) ~ ll ListTools(); ll Lire liste noms outils disponibles Il Fonctions de mots-clés générales void SetKeywordValue( ll Ajouter mot-clé à la liste const TsStr& name, ll Chaîne nom mot-clé
const TsStr& value ); //-Chaîne valeur de mot-clé
const TsStr& GetKeywordValue( ll Trouver valeur de mot-clé pour const TsStr& keyword ) const; ll nom mot-clé donné
void RemoveKeyword( ll Trouver définition de mot-clé
const TsStr& keyword ); ll objet pour nom mot-clé donné
Doubly_linked list(TsStr) * ll Trouver noms de GetGroups(const TsKwdExpr& exp); ll Critères rencontre groupes Doubly_linked_list(TsStr) * ll Trouver noms de GetGroups(const TsKwdlnfo& inf); ll Critères rencontre groupes Il Fonctions pour exécuter des opérations specifiques (import, export, etc.) void Dolmport(); ll Exécute opération import void DoExport(); ll Exécute opération export void DoTransfer(); ll Exécute opération transfert ll Autres fonctions de classes operator int () const; ll Enregistrer entier void Print(); ll Imprimer valeurs dans objet }; ll Fin classe TsControl 25 La classe SysConfig est une classe spécifique du fichier de configuration dans l'environnement de l'invention. L'instantiation permet de fixer le nom d'accès du fichier de configuration. Cette classe peut être utilisée de deux manières.

~t~2~4g Selon une première manière, lors de l'installation, un exécutable appelé avec unindicateur spécial et le nom d'accès du fichier de configuration instancie cetteclasse et appelle la fonction statique "SysConfig::AppendLocalConfiguration()"
qui a juste à appeler la table de configuration courante de l'exécutable (à partir s d'une table statique) à la fin du fichier. Toute information pour l'exécutablecourant qui existait antérieurement dans le fichier est annulée.

Selon l'utilisation normale, la classe SysConfig présente une fonction "SysConfig::LoadFile()" d'enregistrement et d'analyse du fichier de configuration 10 et de création des structures de données d'exécutable, de groupe, de méthode,etc., qui représente ce qui existe dans la présente installation. La fonction LoadFile() vérifie également que la configuration de l'exécutable courant correspond à ce qui est dans le fichier de configuration. Une série de fonctions"SysConfig::Find...()" offre un accès rapide aux structures du système pour la 15 récupération de l'information de configuration.

classe SysConfig {

TsStr pathname; ll Nom d'accès au fichier configuration TsFileReader *input; ll Objet pour lecture configuration TsFileWriter *output; ll Objet pour écriture configuration Singly_linked_ring(TsExeclnfo *) exec_list; ll Structures données configuration TsExeclnfo *curr_exec; ll Pointeur vers info courante exécution TsGrouplnfo *curr_group; ll Pointeur vers groupe courant TsMethodlnfo *curr_method; ll Pointeur vers méthode courante SysConfig(const TsStr& path); ll Constructeur ~SysConfig(); ll Destructeur int LoadFile(); ll Lecture et analyse fichier TsExeclnfo *FindExec(const TsStr& name, ll Trouver exécutable nommé
const TsStr& location); ll TsGrouplnfo *FindGroup(const TsStr& name); t/ Trouver groupe nommé
TsMethodlnfo *FindProc(const TsStr& name); ll Trouver méthode nommée static int AppendLocalConfiguration(); ll Ecriture info dans fichier static int DeleteLocalConfiguration(); ll Annulation info dans fichier }

La classe OperCtlScript est une classe spécifique des scripts de contrôle de l'environnement de l'invention. L'instantiation permet de fixer le nom d'accès du script de contrôle. La fonction "OperCtlScript::LoadFile()" est utilisée pour 10 enregistrer et analyser le script de contrôle en creant un liste d'opérations à
exécuter avec les listes correspondantes de définitions de mots-clés.

La fonction "OperCtlScript::SaveFile()" est utilisée pour sortir les définitions et les commandes d'un script de contrôle. Cette classe renferme également des fonctions pour l'exécution des commandes et la configuration et l'appel de l'exécutable suivant.

classe OperCtlScript {

TsStr pathname; ll Nom d'accès du script int temp; ll Indicateur temporaire de script TsFileReader *input;ll Objet pour lecture script TsFileWriter *output;ll Objet pour écriture script TsExeclnfo *curr_exec;ll Exécutable courant TsGrouplnfo *curr_group;//Groupe courant TsMethodlnfo *curr_method;ll Méthode courante Singly_Linked_List(TsMethodlnfo *) commands; ll Commandes à exécuter Singly_Linked_List(TsDef *) defines; ll Paramètres pour commandes SysConfig *system; ll Pointeur vers l'objet SysConfig TsStr next_exec; ll Exécution suivante à effectuer TsStr next_loc; ll Emplacement exécution suivante 21920~9 . 19 OperCtlScript(const TsStr& path); ll Constructeur ~OperCtlScript(); ll Destructeur int LoadFile(); ll Lecture et analyse fichier int SaveFile(); ll Ecriture configuration fichier int SaveFile(const TsStr& new_path); ll Creation nouveau fichier int RunCommands(); ll Appel méthodes int PassExecution(); ll Appel nouvel exécutable }

La classe TsDef est utilisée pour stocker et récupérer les mots-clés et les valeurs d'un script de contrôle.

classe TsDef {
TsStr keyword; ll Identifiant mot-clé
TsStr value; ll Valeur mot-clé

TsDef(const TsStr& kwd, const TsStr& val); ll Constructeur ~TsDef(); ll Destructeur void SetValue(const TsStr& val); ll Fixer valeur de mot-clé
const TsStr& GetKeyword(); ll Lire identifiant de mot-clé
const TsStr& GetValue(); ll Lire valeur de mot-clé
}

La classeTsKwdlnfo est utilisée pour stocker et récupérer les mots-clés et demander les identifiants d'un fichier de configuration. Un objet de cette classe stocke également un pointeur vers l'objet TsDef contenant la valeur courante (définition la plus récente) du mot-clé.

classe TsKwdlnfo {

TsStr keyword; ll Identifiant mot-clé
int prompt_id; ll Message chaîne guide TsDef *definition; ll Pointeur vers objet valeur mot-clé

TsKwdlnfo(const TsStr& kwd, ll Constructeur const TsStr& prmt); ll ~TsKwdlnfo(); ll Destructeur int SetDef(const Singly_linked_list(TsDef *)& defs); ll Fixer valeur mot-clé
const TsStr& GetKeyword(); ll Lire identifiant de mot-clé
const TsStr& GetValue(); ll Lire valeur de mot-clé
const TsStr& GetPrompt(); ll Lire chaîne guide }

La classe TsMethodlnfo est utilisée pour identifier une méthode avec ses mots-clés et options associés.
- class TsMethodlnfo {

TsStr name; ll Nom de méthode TsGrouplnfo *group; ll Retour pointeur vers objet groupe Singly_linked_list(TsKwdlnfo *) kwd_list; ll Liste mots-clés Singly_linked_list(TsKwdlnfo *) opt_list; ll Liste options TsMethodlnfo(const TsStr& nam, TsGrouplnfo *grp); ll Constructeur -TsMethodlnfo(); ll Destructeur const TsStr& GetName(); ll Lire nom méthode TsGrouplnfo *GetGroup(); ll Lire pointeur vers objet groupe void AddKeyword(TsKwdlnfo *kwd); ll Ajouter mot-clé à liste -void AddOption(TsKwdlnfo *opt); ll Ajouter option à liste TsKwdlnfo *FindKey(const TsStr& key_name); ll Lire mot-clé
}

s La classe TsGrouplnfo est utilisée pour identifier un groupe et ses méthodes associées.

classe TsGrouplnfo {

0 TsStr name; ll Nom groupe TsExeclnfo *exec; ll Retour pointeur vers exécutable Singly_linked_list(TsMethodlnfo *) method_list;// Liste méthodes TsGrouplnfo(const TsStr& nam, TsExeclnfo *exc);// Constructeur -TsGrouplnfo(); ll Destructeur const TsStr& GetName(); ll Lire nom groupe TsExeclnfo *GetExec(); ll Lire pointeur vers objet exécutable void AddProc(TsMethodlnfo *method); ll Ajouter méthode à liste TsMethodlnfo *FindProc(const TsStr& method_name);// Lire méthode }

La classe TsExeclnfo est utilisée pour identifier un exécutable et ses groupes associés.

classe TsExeclnfo {
TsStr name; ll Nom exécutable TsStr location; ll Nom d'accès exécutable Singly_linked_list(TsGrouplnfo *) group_list; ll Liste groupes 219~0~9 TsExeclnfo(const TsStr& nam, ll Constructeur const TsStr& location); ll ~TsExeclnfo(); ll Destructeur const TsStr& GetName(); ll Lire nom exécutable const TsStr& GetLocation(); ll Lire chemin exécutable void AddGroup(TsGrouplnfo *group); ll Ajouter groupe à liste TsGrouplnfo *FindGroup(const TsStr& group_name); ll Lire groupe }

Il est à présent proposé des définitions de classes relatives à la représentation des modèles et métamodèles stockés en mémoire et à l'allocation dynamique des objets de modélisation. Le mécanisme (appelé mécanisme D sur la figure 2) utilisé permet de stocker en mémoire, pour accès par les composants de la passerelle, une définition de métamodèle et un modèle de données en allouant dynamiquement les objets du modèle dans ladite mémoire. Ce mécanisme permet de charger un métamodèle puis de construire un modèle en utilisant le gabarit du métamodèle. Une telle construction permet avantageusement une rapide mise en correspondance entre les objets, les définitions de propriété et 20 leurs instances. Le mécanisme D possède des classes privées cachées et des classes d'interface publiques. Pour stocker et accéder aux données dans les objets, un programme utilise des fonctions des classes d'interface publiques TsOBJ et TsLNK. Les objets d'adressage utilisent des index dans un arbre d'un ensemble de pointeurs pour une classe d'objet ou de lien, une instance d'objet, 25 un type de propriété et une liste de lignes de la valeur, la classe d'objet ou de lien et le type de propriété peuvent être donnés comme des noms de texte que les interfaces font correspondre aux valeurs d'index. Outre les ensembles de pointeurs pour un accès direct à une vue hiérarchisée des données, le mécanisme D possède des ensembles d'index classés par valeurs de propriétés-30 clés d'objets correspondants qui fournissent un accès rapide (recherchedichotomique) aux objets sélectionnés et permettent des affichages d'objets classés par champs-clés.

Le "constructeur" du mécanisme D va appeler la fonction readMetaModel pour 35 lire le fichier de définitions de propriétés et d'objets. Cette routine va créer une définition de classe d'objet pour chaque type d'objet, en insérant l'adresse de définition de classe d'objet dans l'ensemble de classes d'objets ordonné par nomde classe. Le mécanisme D supporte l'héritage. En outre, il insère chaque propriété dans un ensemble de propriétés ordonné par nom de propriété. Une 5 fois que`les objets et les propriétés sont définis, I'index de classe d'objet et chaque index de propriété de classe d'objet sont figés, prêts à être utilisés à la construction d'un modèle Un outil construit et manipule un modèle (outil ou modèle d'information neutre 10 NIM) dans ce mécanisme D. Lorsqu'il est appelé pour fixer une valeur de propriété, le mécanisme D exécute les étapes suivantes qui sont optimisées lorsque les noms sont déjà mis en correspondance avec les valeurs d'index et que les objets créés à la demande existent déjà:

- recherche du nom de type objet dans le tableau des classes d'objets pour lire l'index cllNdx, - à la position clNdx dans le tableau d'objets de modèle, trouver ou créer l'élément pour le tableau d'instances d'objets et affecter un nouvel index objNdx, - créer un nouvel objet et stocker son adresse dans le tableau d'instances d'objets, - chercher le nom de propriété dans le tableau de définitions de propriétés 25 pour trouver l'index propNdx, - à la position propNdx dans le tableau d'instances de propriétés d'objets, trouver l'adresse de valeur de propriété ou en créer une nouvelle et y stocker cette adresse, - chercher le numéro de ligne dans la liste de valeurs de propriétés, si trouvé stocker la valeur dans l'objet valeur de propriété, sinon créer une nouvelle valeur de propriété et l'insérer dans la liste, - indexer le tableau d'instances de propriétés pour trouver où stocker le pointeur valeur de propriété, - ` 2192~49 - en stockant une valeur primaire ou secondaire de propriété-clé, insérer ou mettre à jour l'index objNdx dans la table d'index correspondante ordonnée par la valeur clé.

5 Le tableau d'instances de propriétés est une concaténation des pointeurs de propriété de classe courant et antérieurs.

Les classes TsDynamo, TsOBJ, et TsLNK définissent l'interface utilisateur pour l'accès au mécanisme D. La classe TsOBJ permet d'indexer la classe, I'objet, la 10 propriété et la ligne en fournissant un mécanisme d'adressage dans les objets du mécanisme D. La classe TsLNK opère l'adressage des liens du mécanisme D.
L'interface du mécanisme D offre à l'utilisateur un domaine d'application (modélisation de données) et cache les pointeurs, les structures et l'allocationmémoire C++. Les itérateurs TsOBJ bouclent sur toutes les classes d'objets ou 15 toutes les occurences d'une classe d'objets ou toutes les propriétés. Un programme peut parcourir un modèle ou sélectionner une partie ou un sous-arbre d'objets et de propriétés. Les itérateurs TsLNK (dérivée des itérateurs TsOBJ) bouclent sur les liens. Un programme peut explorer un modèle en traversant des liens entre objets. Un lien peut avoir des propriétés parce qu'il20 hérite de cette possibilité de la classe TsOBJ.

La classe TsDynamo présente des objets (objet C++ appelé objet dynamo dans la suite) qui désignent un métamodèle et un modèle en train d'être manipulés.
Un objet TsOBJ désigne un objet dynamo et contient les index d'une position 25 dans le modèle. La position d'un objet TsOBJ peut être fixée par des noms de classes et de propriétés dans des chaînes de caractères eVou par des valeurs d'index. Ceci permet d'allier la polyvalence des noms à l'exécution a l'efficacité
d'utilisation de sous-scripts. Les valeurs d'index égales à 1 correspondent à des valeurs implicites.
#include <tsdynamo.h~

TsDynamo PAC("pac", "Test Model"); h construire PACLAN/X (outil) TsDynamo NlM("nim", "Neutral Model"); ll construire NIM
TsOBJ PAC_ORB(PAC, "ORB"), while (PAC_ORB.nextObj()) ll itération sur tout l'ORB
{

if (PAC_ORB("TYPE") != "O") continue; ll sélection OBJs, sauter RELs TsOBJ NIM_BEN(NIM, "BEN");
NlM_BEN.setObj(); ll créer nouveau BEN

5 NIM_BEN("TITLE") = PAC_ORB("NAME"); ll copier propriétés NIM_BEN("ALIAS") = PAC_ORB("CODE");

NIM_BEN("NOTES", 1 ) = "%PX8_CODE " + PAC_ORB("CODE"); ll concaténation propriétés 10 NIM_BEN("NOTES", 2) = "%PX8_NAME " + PAC_ORB("NAME"); ll seconde ligne de NOTES

NIM_BEN("NOTES") += PAC_ORB("DOC"); ll annexer à l'ensemble ou bloc NIM_BEN("TITLE") += "_suffix"; ll concaténer à la valeur NIM_BEN("PROP") = Str(PAC_ORB("PROPERTY"),5,6); ll déplacement sous-chaîne 5, longueur 6 }

Attention: TsOBJ = TsOBJ; signifie copier la valeur de propriété et non l'objet TsOBJ!

TsOBJ nim_obj(nim); ll copier clones constructeur TsOBJ nim nim_obj.copy(nim); ll copier TsOBJ nim dans TsOBJ nim_ob;
nim_obj = nim; ll copier valeur property de nim vers nirn_obj Fichiers "Include" référencés #include "tsarray.h"
#include "tsstr.h"
#include "tsrec. h"
Manipulateurs l/O
30 #define setleft setiosflags(ios::left) #define resetleft resetiosflags(ios::left) Exécution pas à pas macros extern int Tracing;
5 #define TRACE(arg) if (Tracing) cout << setw(5) << _LINE_ << " " << arg <<
NL;

2192Q~9 #define COPL(c) "TsOBJ(" ~< c->classNdx ~< "," << c-~objNdx ~< "," ~ c->propNdx ~ c->lineNbr ~
Tailles ensemble - Croissance incréments TsArray const int MaxClass = 128; ll Types de classe (pas instances d'objets) 5 const int MaxProps = 64; ll Propriétés par objet const int MaxKeys = 64; ll Capacité de bloc-clé
Types de propriété définis dans métamodèles enum TsPropType { Value=1, ll valeur de chaîne simple Array=2, ll valeurs de chaîne indépendante multiple Block=3}; ll lignes multiples de texte continu extern const char* TsPropTypeStr[]; ll disposition pour conversion "enum"
en chaîne inline const char~ cvPropType(TsPropType t) ll convertir "enum" en chaîne pour affichage {

return TsPropTypeStr[t >= Value && t ~= Block ? t: 0];
}

Références - class TsDynamo;
class TsPropValue;
class TsObjectlnst;
class TsObjKeyArray;
class TsObjlnstArray;
class TsModelObjArray;
class TsPropDefnArray;
class TsPropDefn;
class TsObjClassDefn;
class TsObjClassArray;
class TsLinklnst;
class TsLinkKeyArray;
class TsLinklnstArray;
class TsModelLnkArray;

2192Q~9 Dynamo - Classe d'interface classe TsDynamo {

friend class TsOBJ;
s friend class TsLNK;

class TsObjClassArray* oca; //Tableau des classes d'objets du métamodèle class TsModelObjArray* moa; 11 Tableau d'objets du modèle class TsLnkClassArray* Ica; 11 Tableau de classe de liens du métamodèle class TsModelLnkArray* mla; 11 Tableau de liens du modèle TsDynamo(const char* metaModelName, const char* modelName);
TsDynamo(const TsDynamo& d, const char* modelName);
Il même métamodèle1 nouveau modèle 20 ~TsDynamo(); 11 destructeur void display(); 11 Exploration Dynamo, valeurs d'affichage void dump(); 11 copie image modèle dans objet,i9,propriété,i9,valeur format (OBS) 5 void writeNDF(char* ndfPath); 11 Exploration Dynamo, valeurs ecrlture int readMetaModel(const char* fileName); 11 lire objeVdéfinitions propriété
void define(const char* obj, const char* prop, char* key, TsPropType prop Type, int prop_Size); 0 void freeze();

Dans la classe TsOBJ, un objet TsOBJ est un pointeur pour des objets d'adressage dans un objet dynamo. Les fonctions TsOBJ permettent d'accéder 35 aux objets dynamo par indexation de la table de pointeurs en utilisant quelques unes ou toutes les valeurs Ndx.

classe TsOBJ ll Numéros d'index pour adresser une valeur dans le mécanisme D
5 {

TsDynamo* dyn; ll pointeur pour situer données dans dynamo int classNdx;
int objNdx;
int propNdx;
lineNbr;

int iterNdx; ll index ensemble clé pour itérateurs, commencer à -1 int error; Il O: ok, >0: adresse défaillante, saut Constructeur TsOBJ avec valeurs numériques TsOBJ(TsDynamo& aDyn, int aClassNdx=1, int aObjNdx=1, int aPropNdx=1, int aLineNbr=1 );

Constructeur TsOBJ avec noms de classes et de propriétés TsOBJ(TsDynamo &aDyn, const char* aClass, int aObjNdx=1, const char* aProp=1, int aLine=1 );
Constructeur de copie TsOBJ
30 TsOBJ(TsOBJ& c);

TsOBJ Destructeur ~TsOBJt) {}

Fonctions pour adresser les objets dynamo via TsOBJ

2192~49 TsStr& getV();
TsPropValue* getPropValue();
TsObjectlnst* getObject();
TsObjKeyArray* getPrimeKeyArray();
5 TsObjKeyArray* getSecndKeyArray();
TsObjlnstArray* getObjlnstArray();
TsModelObjArray* getModelObjArray();
TsPropDefnArray* getPropDefnArray();
TsPropDefn* getPropDefn();
10 TsObjClassDefn* getObjClassDefn();
TsObjClassArray* getObjClassArray();
char* getClassName();
char* getPropName();

Fonctions pour fixer et lire les valeurs d'objets et de propriétés dans un modèle int setObj(const char* aClass, int aObjNdx=1 );
int setProp(const char* aProp);
int setValue(const char* aProp, int aLineNbr, const char* aValue);
int setValue(int aLineNbr, const char* aValue);
int setValue(const char* aValue) {return setValue(1, aValue);}
int setValue(TsStrList* aValue);
- TsStr getValue(const char* aObj, int aObjNdx, const char* aProp, int aLineNbr=1 );
TsStr getValue(const char* aProp, int aLineNbr=1 );
TsStrList getList(const char* aProp);
TsPropType getPropType();
int findObj(const char* aObj, const char* aProp, const char* aValue);

Fonctions d'opérateur pour améliorer la syntaxe des passerelles TsOBJ& operator() (const char* aObj, int aObjNdx, const char* aProp, int aPropNbr);
TsOBJ& operator() (const char* aObj, int aObjNdx, const char* aProp);
TsOBJ& operator() (const char* aObj, char* aProp);
35 TsOBJ& operator() (const char* aProp, int aLineNbr);
TsOBJ& operator() (const char* aProp);
TsOBJ& operator() (); ll op() n'autorise pas de défaut 21920~9 TsOBJ& copy(TsOBJ& b); ll copier TsOBJ

TsOBJ& operator= (TsOBJ& in); ll copier la valeur de propriété
TsOBJ& operator= (const char* in); ll copier la valeur de chaîne TsOBJ& operator+= (TsOBJ& in); ll annexer la valeur de propriété
TsOBJ& operator+= (char* in); ll annexer la valeur de chaîne 0 int operator!() {return error;} ll signaler si dernière réf ou affectation défaillante operator TsStr&() {return getV();} //conversion de op active tous Str ops Fonctions itérateur pour parcourir les classes, objets, propriétés, lignes.
Retour à 0 quand la dernière occurrence est dépassée, pour arrêter l'itération.
Pointeurs "null" intégrant un saut dans les ensembles.
int firstClass();
20 int firstObject();
int firstProperty();
int firstLine();

int nextClass();
25 int nextObject();
int nextProperty();
int nextLine();
};

Cardinalité
enum Cardn {C0_1, C1_1, C0 M, C1_M};

extern char* Cardn str[]; ll ensemble chaîne pour convertir Cardn en texte Paire index de classe et index d'objet pair pour trier une valeur de propriété clé
struct Clob 5 {
int classNdx;
int objNdx;
};

10 Dans le mécanisme- D, les classes "Metamodel" représentent le modèle d'information neutre NIM ou le métamodèle de l'outil concerné comme une structure constante pour interpréter les données dans le modèle à manipuler.

Définitions de classes d'ensemble de définition de propriété
Ensemble de chaînes pour convertir "enum" en texte const char* TsPropTypeStr[] = {"??", "Value", "Array", "Block"};
classe TsPropDefn ll contenu dans PropDefnArray {

20 friend class TsPropDefnArray;
friend class TsObjectlnst;
friend class TsOBJ;

TsStr propName;
2s TsPropType type;
int length;

TsPropDefn(const char* aPropName, TsPropType aType, int aLength);
-TsPropDefn() {}

3s Ensemble définition de propriété
TsArray(TsPropDefn*, TsPropDefnPtArray); ll spécialise le gabarit classe TsPropDefnArray {

friend class TsObjClassDefn;
friend class TsObjClassArray;
friend class TsObjectlnst;
friend class TsDynamo;
friend class TsOBJ;

TsPropDefnPtArray Prop;

TsPropDefnArray(): Prop(MaxProps) {}
~TsPropDefnArray(); ll supprime chaque objet désigné par le tableau void display(TsOBJ* at);

20 TsPropDefn* define(const char* aName, TsPropType aType, int aLength);
TsPropDefn* insert(const char* aName, TsPropType aType, int aLength);

int getlndex(const char* aName);
TsPropDefn* find(const char* aName);

};

Trouver le nom de propriété et renvoyer son index de tableau (ou 0) 30 int TsPropDefnArray::getlndex(const char* name);

Trouver le nom de propriété et renvoyer l'adresse de PropDefn (ou NULL) TsPropDefn* TsPropDefnArray::find(const char* name);

Insérer TsPropDefn dans TsPropDefnArray trié par nom de propriété

- ` 2lg2oA9 _ 33 TsPropDefn* TsPropDefnArray::insert(const char* aName, TsPropType aType, int aLength);

Définir un nouveau TsPropDef, vérifier si le nom de propriété est un s doublon TsPropDefn* TsPropDefnArray::define(const char* Name, TsPropType Type, int Length) Définition de classe d'objet, information d'objet de métamodèle class TsObjClassDefn {

friend class TsObjClassArray;
friend class TsObjlnstArray;
friend class TsObjectlnst;
friend class TsDynamo;
friend class TsOBJ;

TsStr className; ll nom classe d'objet 20 TsStr parentName; llnom d'objetayantune parenté
TsObjClassDefn* parent; ll propriétés héritées TsPropDefnArray* pda; ll recherche dichotomique pour nom de propriété

TsStr primeKeyName;
int primeKeyPrNdx;

TsStr secndKeyName;
int secndKeyPrNdx;

TsObjClassDefn(const char* Name, const char* ParentName=O, const char* Prime=O, const char* Second=0);

35 ~TsObjClassDefn() void TsObjClassDefn::display(TsOBJ* at);

Traduire les index de propriété-clé lorsque le métamodéle est figé
void TsObjClassDefn::resolveKeys() };

s Définition du tableau de classes d'objets Tableau de classes d'objets, sommet du métamodéle TsArray(TsObjClassDefn*, TsObjClassDefnPtArray); ll spécialise le gabarit classe TsObjClassArray 10 {
friend class TsOBJ;
TsObjClassDefnPtArray Class;
15 TsStr metaModelName;

int usageCount; ll protège le métamodèle commun int isFrozen; ll 0=find insère nouvel obj/prop defns TsObjClassArray(const char* name): Class(MaxClass);
~TsObjClassArray();
void release() {if (--usageCount == 0) delete this;}
void display(TsOBJ* at);
25 void writeNDF(TsOBJ* at, ostream& ndf);
void resolveKeys();
TsObjClassDefn* define(const char* name);
TsObjClassDefn* defineKey(const char* obj, char* key, const char* prop);

30 TsObjClassDefn* insert(const char* name);
TsObjClassDefn* find(const char~ name);
int getlndex(const char* name);
};

Traduire le nom de classe ayant une parenté et les index de propriété-clé
void TsObjClassArray::resolveKeys();

219204~

Trouver l'index du tableau pour le nom de classe d'objet int TsObjClassArray::getlndex(const char* name) Trouver l'adresse de définition de classe d'objet par son nom de classe d'objet TsObjClassDefn* TsObjClassArray::find(const char* name) Insérer définition de classe d'objet dans le tableau de classes d'objets trié
par le nom de classe TsObjClassDefn* TsObjClassArray::insert(const char* name) Définir une nouvelle définition de classe d'objet dans le tableau de classes d'objets, vérifier si doublon TsObjClassDefn* TsObjClassArray: :define(const char* name) Définir un premier ou un second nom de propriété-clé
TsObjClassDefn* TsObjClassArray::defineKey(const char* obj, char* key, const char* prop) Dans le mécanisme D, les classes de données de modèle représentent le modèle de l'utilisateur dans la structure définie par le modèle d'information neutre NIM correspondant ou par le métamodèle de l'outil concerné.
Définition de classe de valeur de propriété
classe TsPropValue ll chaîne de valeur de propriété unique {

friend class TsObjectlnst;
30 friend class TsOBJ;

TsPropValue* next; ll les propriétés a multivaleur sont enchaînées int lineNbr; ll fichier de tri pour insertion TsStr v; ll I'affectation de chaîne supporte le redimensionnement 21920~9 TsPropValue(int line_Nbr, const char* val) ~TsPropValue() {}

void display(TsOBJ* at);
void dump(TsOBJ* at);
void writeNDF(TsOBJ* at, ostream& ndf);

10 void set(int line_Nbr, const char* val);
TsStr get(int line_Nbr);
operator const char*() const {return (const char*)v;}
15 };
void TsPropValue::display(TsOBJ* at) void TsPropValue::dump(TsOBJ* at) void TsPropValue::writeNDF(TsOBJ* at, ostream& ndf) Fixer un numéro de ligne et une valeur pour une valeur de propriété
void TsPropValue::set(int line_Nbr, const char* val) 2s Fixer une valeur de propriété multiligne void TsPropValue::set(const TsStrList* val) Lire une valeur de propriété par son numéro de ligne 30 TsStr TsPropValue: :get(int line_Nbr) Lire une valeur de propriété multiligne TsStrList TsPropValue::get() 35 Définition de classe d'instance d'objet L'instance d'objet contient un tableau d'instances de propriétés, elle désigne les valeurs de propriéte TsArray(TsPropValue*, TsPropValuePtArray); //spécialise le gabarit _ 37 class TsObjectlnst ll index parallèle à PropDefnArray {

friend class TsObjlnstArray;
5 friend class TsOBJ;

TsPropValuePtArray Prop;

10 TsObjectlnst(): Prop(MaxProps) {}

-TsObjectlnst() void display(TsOBJ* at);
void dump(TsOBJ* at);
5 void writeNDF(TsOBJ* at, ostream& ndf);
TsPropValue* setValue(TsOBJ* at, const char* val);
};

Définition de classe d'ensemble clé d'objets Ensemble clé d'objet, index d'objet utilisant une propriété clé

TsArray(int, TsObjNdxArray); ll spécialise le gabarit class TsObjKeyArray ll objNdxs trié par valeur de propriété clé
{
friend class TsObjlnstArray;
friend class TsOBJ;

TsObjNdxArray objNdx; ll délivrer dans l'ordre ou recherche dichotomique TsObjKeyArray(): objNdx(MaxKeys) {}
~TsObjKeyArray() {}
35 void display(TsOBJ* at);
void insert(TsOBJ* at);
int find(char* val);
};

` 2192~4~9 Définition de la classe de tableaux d'instances d'objets TsArray(TsObjectlnst*, TsObjectPtArray); ll spécialise le gabarit class TsObjlnstArray ll instances d'objet indexées par objNdx {

friend class TsModelObjArray;
friend class TsOBJ;
TsObiKeyArray* primeKeyArray;
TsObjKeyArray* secndKeyArray;

TsObjectPtArray Obj;

TsObjlnstArray(): Obj(MaxKeys) ~TsObjlnstArray() Positionner un index d'objet, le créer si nécessaire 20 TsObjectlnst* setObject(int objNdx) void display(TsOBJ* at);
void dump(TsOBJ* at);
void writeNDF(TsOBJ* at, ostream& ndf);
void updateKey(TsOBJ* at);
2s };

Mettre à jour un ensemble clé d'objets par insertion en conformité avec la valeur de propriété clé
void TsObjlnstArray::updateKey(TsOBJ* at) Fixer la propriété courante à la valeur donnée TsPropValue* TsObjectlnst::setValue(TsOBJ* at, const char* val) Définition de classe de tableaux d'objets de modèle 21920~9 .~

Ensemble d'objets de modèle, sommet de modèle, désignation d'instances d'objet TsArray(TsObjlnstArray*, TsObjlnstPtArray); ll spécialise le gabarit class TsModelObjArray ll classes d'objets indexées par clndx {

friend class TsOBJ;
TsStr modelName;
TsObjlnstPtArray Class;
10 public:
TsModelObjArray(const char* Name): Class(MaxClass) ~TsModelObjArray() void display(TsOBJ* at);
void dump(TsOBJ* at);
15 void writeNDF(TsOBJ* at, ostream& ndf);

Positionner le tableau courant d'instances d'objets avec l'index de classe TsObjlnstArray* setClass(int classNdx) 20 };

Une définition de classe de liens dans le mécanisme D est une sous-classe d'une définition de classe d'objets. Un lien de modèles est une instance d'un lien. Une définition de classe de liens décrit les classes d'objets que les liens 25 peuvent rattacher. Une instance de lien spécifie les instances d'objets de modèle qui y sont rattachées.

Les objets de lien dérivent d'objets réguliers parce que les liens ont les caractéristiques des objets (ils ont les noms et peuvent avoir les propriétés), 30 mais ils ont également des vecteurs "to" et "from" et une cardinalité. Les éléments de données additionnels aux liens, dans un but d'optimisation des performances, sont codés en langage C++ plutôt que d'être mis en oeuvre comme des propriétés d'objets. Les ensembles d'index triés permettent également d'optimiser la recherche.

Le constructeur du mécanisme D lit les définitions de liens avec les autres définitions d'objets à partir d'un métamodèle d'outil ou du fichier de métamodèles du modèle d'information neutre NIM.

5 Un lien contient les index d'objets clNdx et objNdx provenant et à destinationdesdits objets pour permettre de trouver les objets de modèle qui sont connectéspar le lien. Une définition de lien spécifie les objets qu'elle peut regrouper mais une classe réelle peut être dérivée d'une classe d'objets spécifiée, ainsi les liens contiennent les index clNdx et objNdx. Les liens peuvent posséder des 10 propriétés au même titre que les objets.

Le fait de créer un lien entre deux objets implique aussi son entrée dans les tableaux d'index. Un ensemble de clés de liens est trié pour trouver tous les objets ou des objets spécifiques qu'un type de lien regroupe déjà. Un ensemble 15 de liens d'objets est trié pour trouver tous les liens ou des liens spécifiques provenant ou à destination d'un objet donné. La définition de classe de liens peut contenirun index propNdx d'une propriété dont la valeur détermine l'ordre d'itération au travers des liens d'un objet. Ceci permet d'inspecter les attributs d'une entité et les sous-champs d'un attribut dans un ordre spécifique. Le 20 séquencement par défaut d'ensembles d'index de liens utilise la clé d'objet cible, ce qui facilite les recherches dichotomiques et la mise en ordre des listings.

La structure de passerelle qui permet de mettre en correspondance un modèle d'un métamodèle avec un autre met en oeuvre en fait une hiérarchie de boucles 25 qui utilisent des itérateurs pour inspecter chaque objet primaire d'un modèle et ensuite parcourent ses liens ou utilisent des clés étrangères pour trouver des objets associés. Les autres traitements qui modifient un modèle NIM, soit déjà
implanté soit copié, utilisent ce même type de traitement général pour le contrôle d'intégrité et d'autres opérations de service.
#include "tsdynamo.h"

//Ensemble de chaînes pour mettre en correspondance les valeurs "Cardn enum"
avec le texte char* Cardn_str[] = {"0:1 ", "1:1", "O:m", "1:m"};

Définition de classe de lien - ` 219~49 classe TsLinkClassDefn: TsObjClassDefn {

friend class TsLNK;
5 friend class TsLinkClassArray;

TsStr fromVerb;
TsStr toVerb;

10 int fromClNdx;
int toClNdx;

Cardn fromCardn;
Cardn toCardn;

int toKeyPropNdx; ll mise en ordre d'un ensemble de liens d'objet TsStr toSetMbr;
TsStr fromSetMbr;

TsLinkClassDefn( constchar*aClassName, const char* aFromVerb, const char* aToVerb, const char* aFromClName, const char* aToClName, const char* aFromCardn, const char* aToCardn, const char* aToKeyPropName, const char* aToSetMbr, const char* aFromSetMbr);

void display(TsLNK* at);
};
void TsLinkClassDefn::display(TsLNK* at);

Lien au niveau du modèle 21~2Q49 classe TsLinklnst: TsObjectlnst {

int fromClNdx;
int fromObjNdx;

int toClNdx;
int toObjNdx;

TsLinklnst(TsOBJ& aFrom, TsOBJ& aTo);
~TsLinklnst() {}

void display(TsLNK* at);
void putNDF(ostream& ndf, TsLNK* at);

TsPropValue* setProp(TsLNK* at, const char* val);
};

20 void TsLinklnst::display(TsLNK* at);

Ensemble clé de liens, index de liens triés utilisant une propriété clé
25 TsArray(TsClob, TsClobArray); ll spécialise le gabarit classe TsLinkKeyArray ll InkNdxs triés par la valeur de propriété clé d'objet cible {

30 friend class TsLinklnstArray;
friend class TsLNK;

TsClobArray linkNdx; ll délivrer dans l'ordre ou recherche dichotomique TsLinkKeyArray(): linkNdx(MaxKeys) {}

~TsLinkKeyArray() void display(TsLNK* at);
s void insert(TsLNK* at);

int find(char* val);
};

Mise à jour d'un ensemble de clés de liens, insertion conforme à la valeur de propriété clé
void TsLinklnstArray::updateToKey(TsOBJ* at);

Mise à jour à partir d'un ensemble clé de liens, insertion conforme à la valeur de propriété clé
void TsLinklnstArray::updateFromKey(TsOBJ* at);
Classe TsLNK, classe d'interface 20 La classe TsLNK est dérivée de la classe TsOBJ. Les possibilités supplémentaires de la classe TsLNK concernent l'exploration ou la navigation entre objets dans un modèle par l'intermédiaire des liens dans le métamodèle.

Choisir le lien courant 25 int TsLNK::setLink(const char* aClass, int aLnkNdx);
Il Fixer le lien spécifique aux index donnés Il Faire croître l'arbre de liens si nécessaire int TsLNK::setLink(TsOBJ& from, TsOBJ& to);
Remise à l'état initial du lien courant int TsLNK::resetLink(TsOBJ& from, TsOBJ& to);

Lire la cible du lien spécifique 21920~9 TsClop TsLNK::getTarget();

Lire l'origine (source) du lien spécifique TsClop TsLNK::getSource();

Trouver l'index de lien pour le type de lien requis et la valeur clé
int TsLNK::findLink(const char* aLnk, const char* aProp, const char* aVal);

Insérer l'index d'objet courant dans son ensemble d'index de vecteurs 10 void TsVtrKeyArray::insert(TsOBJ* at) Il est à présent proposé des définitions de classes relatives au codage et décodage des enregistrements dans différents formats de fichiers d'export d'outils.
Descripteurs d'enregistrement pour des champs de longueur variable Les langages C et C++ ne permettent pas de supporter complètement les enregistrements. Ils proposent des ensembles de caractères et des structures 20 avec des éléments de données tels que des ensembles de caractères et des sous-structures. Après qu'une structure a été déclarée, le programmeur doit coder l'information de longueur de nouveau dans le code procédural pour pouvoir accéder à ses contenus. Des champs de longueur variable qui utilisent - des délimiteurs sont, de manière typique, traités par codage de la syntaxe des 25 enregistrements dans le code qui effectue l'analyse syntaxique desdits enregistrements. La solution avantageuse présentée et définie dans le présent cas est de mettre en oeuvre des déclarations d'enregistrements comme une collection de descripteurs de champs. En premier lieu, le programmeur définit des champs de taille fixe et variable et affecte des codes de valeur constante 30 aux types d'enregistrements, ainsi que des valeurs de délimiteurs. Ensuite dans le code procédural, le programmeur appelle des fonctions pour mettre en correspondance un enregistrement avec son descripteur, puis accède aux champs dans l'enregistrement. Pour sortir les informations, le programmeur appelle des fonctions qui permettent de supprimer l'enregistrement, de remplir 35 ses champs et ensuite de fournir l'enregistrement complet pour sa sortie. La description d'enregistrement contient le nom, le type et la taille de l'information au moment de l'exécution. L'information descriptive et les données peuvent être affichées pour la mise au point.

219~0~

Avec la classe TsRec, le fichier tsrec.h définit des macros pour la constructiondes descripteurs d'enregistrement et des prototypes de fonctions pour la mise encorrespondance d'un registre avec une description d'enregistrement en fournissant des données provenant d'un champ de l'enregistrement, en fixant 5 des données dans un champ d'enregistrement et en fournissant un enregistrement complet pour permettre de le sortir.

La classe TsRec peut ainsi traiter un grand nombre de fichiers du mécanisme D
et de fichiers d'export d'outil écrits et lus par les composants de la passerelle.
Définir les types de champs enum TsFieldType {REC, BFR, LIT, FLD, VAR, END};

Une description d'enregistrement est un tableau de structures TsFieldDescr.
struct TsFieldDescr {

TsFieldType type;
char* name;
int length;
};

Macros pour aider les programmeurs à définir des descriptions d'enregistrement 25 #define MaxRec(len) const int RecBufSize = len;
#define XRec(name) extern char RECBUF##name[]; \
extern TsFieldDescr name[];

#define Rec(name) char RECBUF##name[RecBufSize+1]; \
TsFieldDescr name[] = {{REC, #name, 0}, \
{BFR, RECBUF##name, RecBufSize}, #define Lit(string) {LIT, string}
#define Fld(name, len) {FLD, #name, len}
#define Var(name) {VAR, #name}
#define End {END}}

21920~9 Macros pour accéder aux valeurs de champs #define GetFld(rec,fld) geffld(rec, #fld) #define SetFld(rec,fld,val) seffld(rec, #fld, val) Prototypes de fonctions Convertir un entier en ASCII avec des options de base, de taille et de remplissage char* itoa(int value, int base=10, int size=0, char fill=' ');
Convertion inverse d'ASCII en entier int atoi(const char* p);

Fonctions d'enregistrement dynamique Mise en correspondance d'un registre avec un enregistrement int match(char* buffer, TsFieldDescr* f);

Lire un champ d'un enregistrement 20 TsStr geffld(const TsFieldDescr* rec, const char* name);

Lire un champ avec une valeur char*
void seffld(TsFieldDescr* rec, const char* name, const char* value);

25Lire un champ avec une valeur de la classe TsStr (définie ci-après) inline void seffld(TsFieldDescr* rec, const char* name, const TsStr& value);

Lire un champ avec une valeur entière convertie en char*

30inline void seffld(TsFieldDescr* rec, const char* name, const int value) {

seffld(rec, name, itoa(value));

21920 4g }

Supprimer un enregistrement void clear(TsFieldDescr* rec);

Afficher un enregistrement void display(const TsFieldDescr* rec);

Convertir le type "enum TsFieldType" en symbole char*
char* aTsFieldType(const TsFieldType t);

Lire le pointeur de nom d'enregistrement inline char* GetRec(const TsFieldDescr* rec) {return(rec+1 )-~name;}

Déclarer IO_TAF pour être extérieur XRec(lO_TAF);

Il est aussi proposé des définitions de classes relativement à la manipulation de chaînes de caractères.

Définition de la classe de chaînes de caractères TsStr Le fichier en-tête tsstr.h contient les définitions de la classe TsStr qui fournit un type de données de chaînes de caractères particulièrement avantageux car il se comporte comme beaucoup de types de données intégrés en langage C. De grande importance est également le fait d'interdire toute perte d'information généralement associée à des pertes de blocs de mémoire.

Le but de la classe TsStr est de définir une classe de chaînes de caractères C++qui permet de supporter les affectations, les concaténations et les opérateurs de comparaison avec les fonctions de sous-chaîne et de réaffectation dynamique de mémoire tout en conservant la compatibilité avec les chaînes de caractères char* d'un langage de type C.

Nouvelles macros de caractères de ligne 21g'~049 #define NL'~n"
#define NL2 '~n\n"

Affichage variable avec nom s #define SEE(x) " " #x ": " << x Il Usage: cout << SEE(abc) <<
SEE(xyz);

Classe de chaînes de caractères classe TsStr {

char* pt;ll ensemble de caractères alloués dynamiquement size_t In; ll longueur de données courante 15 size_t bs; ll capacité de bloc (stoppeur non compté) Fixer TsStr vide avec taille de bloc par défaut void Defaults() {bs = 16; In = 0; pt = new char[bs+1]; pt[0] = '\0';}
public:
Construire la classe TsStr, initialisée par la chaîne de caractères char*
TsStr(const char* cp);
Construire la classe TsStr, initialisée par TsStr 2s TsStr(const TsStr& b);
Construire la classe TsStr par défaut TsStr() {Defaults();}
Construire une classe TsStr vide avec une taille de bloc donnée TsStr(int len);

Construire une classe TsStr, une chaîne de caractères char* et une longueur étant données TsStr(const char *cp, const int len);

21920~9 ~_ 49 Destructeur: supprimer l'ensemble de caractères ~TsStr() {delete [] pt;}

Affecter une classe TsStr = a TsStr 5 TsStr& operator = (const TsStr &b);
Affecter une classe TsStr = a char* string TsStr& opérator = (const char* bpt);
Affecter une classe TsStr = un caractère TsStr& opérator = (char b);
Concaténer une classe TsStr + une classe TsStr TsStr& opérator + (const TsStr &b) const;
Concaténer une classe TsStr + une chaîne de caractères char*
TsStr& operator + (const char* bpt) const;
Annexer une classe TsStr à une classe TsStr TsStr& operator += (const TsStr &b);
Annexer une chaîne de caractères char* à une classe TsStr TsStr& operator += (const char* bpt);
Annexer un caractère à une classe TsStr TsStr& operator += (char b);
Convertir une classe TsStr en chaîne de caractères char*
operator char* () {return pt;} ll opérateur de conversion Convertir une référence constante de la classe TsStr en une chaîne de caractères char*constante operator const char* () const {return pt;} ll opérateur de conversion Comparer une classe TsStr à une classe TsStr int operator == (const TsStr &b) const {return strcmp(pt, b.pt) == 0;}
int operator != (const TsStr &b) const {return strcmp(pt, b.pt) != 0;}
int operator ~ (const TsStr &b) const {return strcmp(pt, b.pt) > 0;}
int operator >= (const TsStr &b) const {return strcmp(pt, b.pt) >= 0;}
30 int operator < (const TsStr &b) const {return strcmp(pt, b.pt) < 0;}
int operator <= (const TsStr &b) const {return strcmp(pt, b.pt) <= 0;}

21g20q9 Compare une classe TsStr à une chaîne de caractères char*
int operator == (const char* b) const {return strcmp(pt, b) == 0;}
int operator != (const char* b) const {return strcmp(pt, b) != O;}
int operator > (const char* b) const treturn strcmp(pt, b) > 0;}
int operator >= (const char* b) const {return strcmp(pt, b) >= 0;}
int operator < (const char* b) const {return strcmp(pt, b) < 0;}
int operator <= (const char* b) const {return strcmp(pt, b) <= 0;}

Comparer une chaîne de caractères char* à une classe TsStr friend int operator==(const char* a, const TsStr &b){return strcmp(a,b.pt)==O;}
friend int operator!=(const char* a, const TsStr &b){return strcmp(a,b.pt)!=O;}
friend int operator> (const char* a, const TsStr &b){return strcmp(a,b.pt)> O;}
friend int operator>=(const char* a, const TsStr &b){return strcmp(a,b.pt)>=0;}
friend int operator< (const char* a, const TsStr &b){return strcmp(a,b.pt)< 0;}
friend int operator<=(const char* a, const TsStr &b){return strcmp(a,b.pt)<=0;}
Opérateur de sortie de chaîne pour la classe TsStr friend ostream& operator << (ostream& s, const TsStr& a) {return s << a.pt;}
Opérateur d'entrée de chaîne pour la classe TsStr - lire une ligne friend istream& operator >> (istream& s, TsStr& a);
Lire pointeur de chaîne de caractères char* de la classe TsStr friend char* getPt(const TsStr& s) {return s.pt;}
Lire longueur de chaîne de la classe TsStr friend int strlen(const TsStr& s) {return s.ln;}
Lire un caractère de la classe TsStr avec un décalage donné
friend char ch(const TsStr& str, int offset) {return str.pt[offset];}

}; ll fin de la définition de classe TsStr Suivent les descriptions de classes et de fichiers contenant des classes utilisées dans l'environnement de la présente invention.

Définitions de la classe d'entrée/sortie TsFile 219~049 Le fichier en-tête tsfile.h contient les définitions des classes TsFile, TsFileReader, TsFileWriter, TsDataReader et TsDataWriter. Ces classes permettent d'encapsuler des opérations d'entrée/sortie du fichier.

5 La classe TsFile permet d'encapsuler les appels du système UNIX (marque déposée licenciée exclusivement par l'intermédiaire de X/OPEN Company Ltd) qui exploitent un pointeur de fichier, I'ouverture et la fermeture du fichier étant traitées par les constructeurs et les destructeurs, la tâche du demandeur est considérablement simplifiée.

Les autres classes construites avec cette encapsulation offrent la possibilité de lire et d'écrire une ligne à la fois et donc un fichier entier à la fois.

classe TsFile { ll FILE * const fp; ll pointeur de fichier TsFile( ll Constructeur const char ~path, ll Nom d'accès de fichier const char *mode = "w"ll Mode d'ouverture ); ll -TsFile(); ll Destructeur int flush(); ll Surcharge file d'attente char *gets(char *s); ll Surcharge en lecture(s) int puts(char *s); ll Surcharge en écriture (s) int putc(char c); ll Surcharge en écriture (c) }; ll Fin de classe TsFile Il classe TsFileReader ll Lit des lignes d'un fichier {
TsFile *f;
char *buffer;

- 219z04~

TsFileReader( ll Constructeur const char *path, int buffer_size );
-TsFileReader(); ll Destructeur char *getnext(); ll Lire données suivantes };

classe TsFileWriter ll Ecrit des lignes dans un fichier {

TsFile *f;
enum {NEW, APPEND};
TsFileWriter( ll Constructeur const char *path, int new or append ~TsFileWriter(); ll Destructeur int putnext(char *buffer); ll Ecrire données suivantes int putnewline(); ll Ecrire un caractère de nouvelle ligne };

classe TsDataReader {

25 Singly_linked_list(TsStr) datalist;
TsDataReader(); ll Constructeur ~TsDataReader(); ll Destructeur void loadfile(const char *path); ll Charger un fichier dans liste Singly_linked_list(TsStr)& getlist(), ll Lire dans la liste void print(); ll Imprimer la liste };

classe TsDataWriter 5 {
Singly_linked_list(TsStr) datalist;
TsDataWriter(); ll Constructeur ~TsDataWriter(); ll Destructeur void setlist(Singly_linked list(TsStr)& L);ll Organiser liste pour écriture 10 void dumpfile(const char ~path); ll Sortir liste de fichier void print(); ll Imprimer la liste };

En ce qui concerne le fichier de données neutre NDF, son format permet de 1s stocker un modèle de manière séquentielle. Le fichier NDF peut représenter des modèles sous la forme d'un modèle d'information neutre NIM ou d'un métamodèle d'outil. Le fichier NDF permet de préserver les classes, les objets, les propriétés et les coordonnées des lignes de la représentation d'un modèle avec les valeurs de propriétés.
Les objets du mécanisme D (appelés objets dynamo) possèdent des fonctions d'écriture dans le fichier NDF qui permettent de stocker un modèle. La possibilité
d'édition à la demande de fichiers NDF s'avère utile pour la génération de données de test. Le format NDF est commode pour évaluer les résultats lors 25 d'exécutions de test. Les développeurs de passerelles peuvent utiliser des fichiers NDF pour sauvegarder ou évaluer des résultats et poursuivre ou relancer des tests en différents points intermédiaires lors du traitement de passerelles.
30 Registre de fichier d'entrée pour l'analyse syntaxique de texte.
classe TsBuffer {

char* buf; ll pointeur de registre char* cp; ll position du caractère courant int bufSize; ll capacité de registre int lineNbr; ll numéro de ligne corant dans le fichier d'entrée int indent; ll espaces eUou tabulations (1 mod 8) comptées comme espaces int rescan; ll 1: saut de lecture, utilise mêmes contenus de registres FILE* fd; ll fichier ouvert par constructeur TsBuffer(const char* aFilePath, int aLen = 256);

~TsBuffer() {delete [] buf;}

Mise en correspondance du texte et d'une valeur à la position courante du registre, progression pointeur int TsBuffer::match(const char* v) Test pour ligne de commentaire int TsBuffer::isComment() - Exploration décrochements, ajustement tabulations int TsBuffer::scanlndent() Lecture ligne de texte, lignes de commentaires ignorées, comptage décrochements, installation de bordures \n int TsBuffer::readBuf() Lecture du mot délimité par "delim"
char* TsBuffer::getWord(char delim) Exploration d'une valeur décimale, renvoi d'une valeur dans un entier, progression curseur int TsBuffer::scanDec() Lecture d'un modèle NDF, construction d'un objet dynamo classe TsReadNDF: registre TsBuffer protégé
{

TsStr metaModelName;
TsStr modelName;
s TsStr objName;
int objNdx;

TsStr propName;
10 int lineNbr;
char* value;

TsDynamo* dyn;
1s TsOBJ* at;
int status;

TsReadNDF(const char* aFileName);
20 };

Lecture fichier NDF et chargement objet dynamo Le constructeur est l'algorithme entier TsReadNDF::TsReadNDF(const char* aFileName): TsBuffer(aFileName) 2s Syntaxe du fichier NDF

Dans la syntaxe du fichier NDF, le décrochement indique un emboîtement. Les lignes de commentaires commencent par "*".

Métamodèle de fichier NDF
Le format suivant du fichier NDF permet de spécifier un métamodele, un modèle et les objets, propriétés et valeurs ainsi que des liens qui constituent un modele.

3s * NDF rev 1.0 ll ligne de commentaires pour identifier le fichier MetaModelName: metaModelName ll Nom du métamodèle requis pour lire le modèle Model: modelName ll Créer un objet dynamo(nom de modèle, nom de métamodèle) Object: Class,ObjNdx ll Créer un objet(classe, indexObjNdx) propld: value ll Fixer propriété de valeur unique propsym: ll Fixer valeurs multiples dans ensemble ou bloc propNdx: value........ Il Une valeur par ligne Link: InkName,lnkNdx ll Créer lien (nom et index du lien) FROM: Class,objNdx ll Fixer point final TO: Class,objNdx ll Fixer point final Il Le fichier "metaModelName.mta" fournit les métamodèles du modèle d'information neutre NIM, PX8, etc..

Il La structure n'est donc pas présente dans le fichier "modelName.ndf".

Il Exemple:

20 * NDF rev 1.0 MetaModelName: nim Model: ndfsample Object: BEN,1 TITLE: My Object X
25 NOTES:
1: %PX8_CODE myobjx

2: %PX8_NAME My Object X
Object: BEN,2 TITLE: another obj 30 NOTES:
1: %PX8_CODE nother 2: %PX8_NAME another obj Object: ATT,1 DATY: DATE
35 NOTES:
1: %PX8_CODE bdate 2: %PX8_NAME birthdate PIC: W-MM-DD

21~2n4s SIZE: 8 TITLE: birthdate Link: BEN1,1 FROM: BEN,2 TO: ATT, 1 Pour conclure, la description précédente du procédé de manipulation de modèles de données selon l'invention, du fait de l'utilisation d'un langage exécuté (par exemple du type C++) pour la construction de passerelles au lieu d'un langage propriétaire interprété, permet de mettre en évidence les effets techniques avantageux dudit procédé prévu pour être appliqué à une nouvelle technologie autorisant l'interopérabilité d'une pluralité d'outils de génie logiciel.
Non seulement tout outil peut être aisément représenté suivant le modèle d'information neutre proposé, mais également toute représentation de modèle interne peut être réalisée, ceci permet à un utilisateur de conserver son propremodèle d'information pour la représentation interne de ses données de développement ou d'exploiter tous les standards de l'industrie comme par exemple le format d'échange de données (CDIF) conçu pour les différents outils de génie logiciel (CASE) associés à un référentiel commun. Le caractère de réutilisabilité du code est pleinement mis à profit et permet ainsi de satisfaire aux contraintes relatives aux délais de mise sur le marché de telles passerelles, alors que les temps et coût de développement desdites passerelles sont très significativement réduits puisque les librairies de code sont réutilisables. De même, est offerte une grande simplification de toute procédure d'ajout de nouveaux composants de passerelles pour faire évoluer et finement adapter un processus de transfert d'un modèle aux besoins spécifiques d'un client. Les performances sont très sensiblement améliorées par le fait que le présent procédé peut être considéré comme l'application d'un simple et unique exécutable.

Claims (4)

1. Procédé de manipulation de modèles de données pour le transfert desdits modèles entre une pluralité d'outils de génie logiciel ayant un format donné et pour l'application de règles de transformation à un desdits modèles, le procédé incluant la transformation de modèles de données au moyen de passerelles pour convertir ledit format d'un outil dans le format d'un autre outil en passant par un format intermédiaire neutre et unique, caractérisé en ce qu'il consiste à développer les passerelles selon une approche orientée objet à partir d'un langage exécuté, les passerelles étant des exécutables permettant la transformation d'un modèle de données en plusieurs étapes, à activer lesdites étapes successivement, de manière systématique ou conditionnelle, en utilisant un langage de commande décrivant une logique d'enchaînement dynamique des étapes, l'enchaînement étant une procédure paramétrée et nommée, chaque étape étant un exécutable dont le code est développé à partir d'un ensemble de classes réutilisables, et à fournir le nom et les paramètres de la procédure à activer.

2. Procédé selon la revendication 1, caractérisé en ce que le développement d'une passerelle consiste à créer une classe réutilisable permettant de représenter les modèles et métamodèles stockés en mémoire dans un référentiel ou dans un fichier externe en utilisant une allocation dynamique des objets de modélisation, les objets de cette classe intégrant un ensemble de structures de mémoire et fournissant des fonctions pour manipuler les données d'un modèle chargé en mémoire.

3. Procédé selon la revendication 1 ou 2, caractérisé en ce que le développement d'une passerelle consiste à créer une classe réutilisable permettant de coder et décoder différents formats de fichiers d'export d'outils, cette classe encapsulant des enregistrements d'export d'outil et étant utilisée pour décrire des formats d'enregistrement d'un fichier d'import, alors qu'à l'initialisation, tandis qu'un métamodèle d'un outil est lu à l'aide de la classe de représentation de modèles et métamodèles stockés en mémoire à partir d'un fichier de texte, le code de la passerelle permet de lire le fichier d'export d'outil, d'accéder aux champs propres aux enregistrements et de créer les objets et leurs propriétés en utilisant les fonctions de la classe de représentation des modèles et métamodèles stockés en mémoire.

4. Procédé selon l'une des revendications 1 à 3, caractérisé en ce que le développement d'une passerelle consiste à créer une classe réutilisable de manipulation de chaînes de caractères qui permet de prendre en charge les affectations, les concaténations et les opérateurs de comparaison avec les fonctions de sous-chaîne et de réaffectation dynamique de mémoire tout en conservant la compatibilité avec les chaînes de caractères d'un langage de type C.