class Process


Héritage :


Méthodes publiques

[more] Constructeurs/Destructeurs
[more] Identification et accès
[more] L'entité attachée au processus
[more] Spécification de la précondition
[more] Spécification du délai de reprogrammation
[more] Affectation de méthodes spécifiques
[more] Affectation d'un corps aux méthodes, et de valeurs aux arguments


o Constructeurs/Destructeurs

o Process(const Process&)
Constructeur par copie. Le nouveau processus porte sur la même entité que le processus copié. Les méthodes sont copiées par les constructeurs par copie des sous-classes.

o ~Process()
Destructeur. Ne détruit pas l'entité sur laquelle le processus opère des changements d'état. Ne détruit pas les méthodes du processus.

o Identification et accès

oProcessSubclassId Subclass() const
Renvoie le type du processus (une des valeurs prédéfinies énumérées de ProcessSubclassId).

oUserProcessId ClassSymbol() const
Renvoie le symbole de classe du processus (une des valeurs énumérées de ProcessId). Cette énumération doit être faite par l'utilisateur dans le fichier UserTypes.h, sous le nom ProcessId.

ovoid ClassName(char*)
Affecte un nom de classe du processus. Pour une exploitation dans le fichier de spécifications de sorties, le nom ne doit comporter que des caractères ASCII.

ochar* ClassName() const
Renvoie le nom de classe du processus.

ovoid SetInstanceName(char*)
Affecte un nom d'instance au récepteur du message, qui surcharge le nom d'instance par défaut attribué par le moteur. Ce nom par défaut est la concaténation du nom de classe et d'un nombre entier positif unique sur l'ensemble de toutes les instances de processus.

oMethod* GetMethod(UserMethodId)
Renvoie la méthode dont le symbole de classe est passé en argument.

oMethod* GetMethod(char*)
Renvoie la méthode dont le nom de classe est passé en argument

o L'entité attachée au processus

On rappelle ici (voir page 'La classe de base des processus') qu'un processus opère un changement d'état sur le système simulé, et qu'il faut spécifier ce qu'on va appeler "l'entité cible" du processus. Cette entité est typiquement la seule que va toucher le processus, mais elle peut aussi n'être qu'une entité touchée parmi d'autres, ou bien encore n'être qu'un point de repère dans la structure du système à partir duquel le code des fonctions va rechercher la ou les entités touchées.

ovoid ProcessedEntityClassId(UserClassId)
Etablit que l'entité sur laquelle le processus opère un changement d'état doit être de la classe dont le symbole est fourni en argument.

oUserClassId ProcessedEntityClassId() const
Renvoie de symbole de classe de l'entité sur laquelle le processus opère un changement d'état.

ovoid ProcessedEntitySpec(EntitySpec*)
Etablit que la spécification d'entités fournie en argument définira l'entité sur laquelle le processus opèrera un changement d'état. Lève l'exception BadProcessedEntitySpec.

oEntitySpec* ProcessedEntitySpec() const
Renvoie la spécification d'entités qui définira l'entité sur laquelle le processus opèrera un changement d'état

ovoid ProcessedEntity(BasicEntity*)
Etablit que l'entité fournie en argument est celle sur laquelle le processus opère un changement d'état. Lève l'exception BadProcessedEntityClass.

oBasicEntity* ProcessedBasicEntity()
Renvoie l'entité sur laquelle le processus opère un changement d'état. Lève l'exception DoNotHaveProcessedEntity.

oEntity* ProcessedEntity()
Renvoie le résultat de ProcessedBasicEntity étendu à la définition de la classe Entity

oBasicEntity* SpecifiedProcessedBasicEntity()
Renvoie l'entité sur laquelle le processus opère un changement d'état, à partir de la spécification attachée au processus. Lève l'exception DoNotHaveProcessedEntity.

oEntity* SpecifiedProcessedEntity()
Renvoie le résultat de SpecifiedProcessedBasicEntity étendu à la définition de la classe Entity.

o Spécification de la précondition
Le message <processus>}->SetPrecondition(f); affecte un corps f à l'instance de Method dont le symbole de classe est PROCESS_PRECONDITION. Ce corps doit retourner un entier positif, nul ou négatif selon que l'action sur le processus peut être réalisée, doit être retardée ou doit être annulée, respectivement. Par exemple, f peut être :
int MyProcessClass_Fct1(ProcessMethod* pM) {
  Process* pP = pM->DescribedDiscreteProcess();
  ...
  return -1;
}

Pour un processus continu la précondition ne joue que sur l'initialisation, c'est-à-dire que la précondition n'est plus testée au cours de vie du processus. Si la fonction renvoie un entier positif (ou si elle est absente), le processus est initialisé. Si elle renvoie 0, un nouvel événement d'initialisation est programmé pour un instant simulé futur (l'horloge courante augmentée de la valeur renvoyée par la méthode PostponementDelay). Si la fonction f renvoie un entier négatif, un événement d'arrêt du processus est programmé pour l'instant courant.

Pour un processus ponctuel, si la fonction f de précondition renvoie un entier positif (ou si elle est absente), le processus est exécuté. Si elle renvoie 0, un nouvel événement est créé par RawCopy() (c'est-à-dire sans duplication des méthodes). Il est alors programmé pour un instant simulé futur (l'horloge courante augmentée de la valeur renvoyée par la méthode PostponementDelay), avec comme seule action l'exécution de ce même processus. Si la fonction renvoie un entier négatif, le processus n'est pas exécuté et aucune nouvelle exécution n'est programmée (abandon).

Dans les deux cas, si une méthode d'autogénération est affectée à l'événement concerné, elle ne sera invoquée que lorsque la précondition du processus deviendra satisfaite, c'est-à-dire lorsque les conséquences de l'événement auront effectivement pu être mises en œuvre.

ovoid SetPrecondition(int (*f)(ProcessMethod*))
Affecte un corps de méthode qui teste la précondition du processus. Ce corps est le pointeur NULL à la construction de l'instance de processus.

o Spécification du délai de reprogrammation
On peut spécifier ce délai directement avec PostponementDelay, ou bien en utilisant la méthode prédéfinie dont le symbole de classe est PROCESS_POSTPONEMENT_DELAY. Si un corps a été donné à la méthode, le moteur de simulation invoquera la méthode. La valeur renvoyée sera passée par le moteur en argument de PostponementDelay.
Le message [/]<processus>}->SetPostponementDelay(f); affecte un corps f à cette instance de Method dont le symbole de classe est PROCESS_POSTPONEMENT_DELAY. Ce corps doit retourner un entier positif. Par exemple, f peut être :
int MyProcessClass_Fct2(ProcessMethod* pM) {
  Process* pP = pM->DescribedDiscreteProcess();
  ...
  return GetIntParameterValue("monProcess" "delai");
}

ovoid SetPostponementDelay(int (*f)(ProcessMethod*))
Affecte un corps de méthode qui renvoie le nombre d'unités de temps simulé après lequel doit être programmé l'événement de "ré-examen" du processus quand il a été retardé (du fait de la non satisfaction de sa précondition). Ce corps est le pointeur NULL à la construction de l'instance de processus.

ovoid PostponementDelay(int)
Détermine le délai (en nombre d'unités de temps simulé) après lequel doit être programmé l'événement de "ré-examen" d'un processus retardé (du fait de la non satisfaction de sa précondition). Il est établi par défaut à 1 dans le constructeur de la classe.

oint PostponementDelay() const
Renvoie le délai après lequel doit être programmé l'événement de "ré-examen" d'un processus retardé (voir l'algorithme de la méthode Run() en début de description de la classe Simulation)

o Affectation de méthodes spécifiques
Outre les méthodes prédéfinies liées à la précondition du processus et, en ce qui concerne les sous-classes, à son exécution, il est possible de décrire un processus par des méthodes spécifiques, en fonction des besoins de l'application. Il faut alors construire l'instance de Method et l'ajouter au tableau des méthodes par une invocation de AddMethod.

ovoid AddMethod(Method*)
Ajoute la méthode à la liste des méthodes du processus, seulement si c'est une méthode de processus.

o Affectation d'un corps aux méthodes, et de valeurs aux arguments
L'appel AssignBody affecte un corps à l'instance de Method dont le symbole de classe est donné en premier argument.

Les méthodes ExecVoidMethod et ExecIntMethod exécutent le corps de la méthode dont le symbole est passé en argument. La présente version n'offre que ces deux possibilités de type de méthode (void et int), et cette unique possibilité de type d'argument (int).

ovoid AssignBody(UserMethodId, void (*f)(ProcessMethod*))

ovoid AssignBody(UserMethodId, int (*f)(ProcessMethod*))

ovoid SetIntArgValue(UserMethodId, UserArgumentId, int)

ovoid SetEntityArgValue(UserMethodId, UserArgumentId, BasicEntity*)

ovoid ExecVoidMethod(UserMethodId)

oint ExecIntMethod(UserMethodId)


Classes descendantes directes :
DiscreteProcess
ContinuousProcess

This page was generated with the help of DOC++.