class Event


Héritage :


Méthodes publiques

[more] Constructeurs/Destructeurs
[more] Opérateurs
[more] Identification et accès
[more] Priorité, probabilité
[more] Date d'occurrence
[more] Processus et directives
[more] L'entité attachée au(x) processus
[more] Spécification des post-conséquences d'un événement
[more] Définition de l'événement autogénéré
[more] Gestion des méthodes spécifiques


o Constructeurs/Destructeurs

o Event(char*)
Constructeur avec affectation d'un nom de classe par ClassName

o Event(UserEventId, char*)
Constructeur avec affectation d'un symbole de classe par ClassSymbol et d'un nom de classe par ClassName

o Event(short, char*)
Constructeur avec affectation d'un degré de priorité et d'un nom de classe par ClassName. Lève l'exception UnexpectedPriorityDegree.

o Event(const Event&)
Constructeur par copie profonde (y compris copie profonde des processus associés) avec copie des méthodes.

oEvent* RawCopy()
Constructeur par copie superficielle, c'est-à-dire sans copie des méthodes, car celles-ci deviennent aussi attachées à la copie. Les processus discrets associés sont copiés superficiellement par RawCopy (c'est-à-dire sans copier leurs méthodes). Les processus continus associés sont copiés par leurs constructeur par copie (c'est-à-dire en copiant les méthodes).

o ~Event()
Destructeur superficiel. Ne détruit pas les méthodes de l'événement. Les processus associés ne sont pas détruits. A utiliser sur un événement qui gère un processus aussi géré par d'autres événements. Les processus qui, de ce fait, resteraient encore en vie en fin de simulation seront détruits dans le destructeur profond de la simulation.

ovoid DeleteInDepth()
Méthode de destruction. Détruit les instances de Method attachées à l'événement. Les processus associés ne sont pas détruits, pour la même raison que ci-dessus.

o Opérateurs

oconst Event& operator=(const Event&)
Opérateur d'affectation. L'événement à gauche pointe sur les mêmes couples {processus, action\} que l'événement à droite. Invoque les opérateurs d'affectation des méthodes. Renvoie une référence à l'entité d'origine.

o Identification et accès

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

ovoid ClassName(char*)
Affecte à la classe le nom donné en argument. Ce nom de classe sera hérité par toutes les instances de la classe. Cette méthode doit être appelée dans les constructeurs d'événements (en invoquant un constructeur de Event qui reçoit le nom de classe en argument ou explicitement dans le constructeur des sous-classes). C'est à l'intérieur de cette méthode qu'est réalisée la liaison de l'événement avec une instance de EventOutputSpec dans le cas où l'utilisateur a demandé la sauvegarde de l'information sur la date de déclenchement (voir page 'Sauvegarde de la chronique des événements'). 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 de l'événement.

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 d'événements.

o Priorité, probabilité

ovoid SetPriorityDegree(short)
Affecte un degré de priorité donné en argument. La valeur doit être comprise entre 0 (priorité forte) et 99 (priorité faible). Lève l'exception UnexpectedPriorityDegree.

oshort PriorityDegree() const
Renvoie le degré de priorité de l'événement.

ovoid SetOccurrenceProbability(float)
Affecte une probabilité d'occurrence à l'événement. La valeur par défaut est 1.0.

ovoid SetOccurrenceProbability(int)
Affecte une probabilité d'occurrence à l'événement (valeur flottante). L'argument doit être entre 0 et 100. La valeur affectée par défaut est 1.0.

ofloat GetOccurrenceProbability() const
Renvoie la probabilité d'occurrence de l'événement.

o Date d'occurrence

oint OccurrenceClockTime() const
Renvoie le moment d'occurrence de l'événement, en nombre d'unités de temps simulé depuis le début de la simulation.

oint MinOccurrenceClockTime() const
Renvoie le moment au plus tôt d'occurrence de l'événement, en nombre d'unités de temps simulé depuis le début de la simulation.

oint MaxOccurrenceClockTime() const
Renvoie le moment au plus tard d'occurrence de l'événement, en nombre d'unités de temps simulé depuis le début de la simulation.

ovoid SetOccurrenceClockTime(int)
Détermine le moment d'occurrence de l'événement, en nombre d'unités de temps simulé depuis le début de la simulation.

ovoid SetMinOccurrenceClockTime(int)
Détermine le moment au plus tôt d'occurrence de l'événement, en nombre d'unités de temps simulé depuis le début de la simulation.

ovoid SetMaxOccurrenceClockTime(int)
Détermine le moment au plus tard d'occurrence de l'événement, en nombre d'unités de temps simulé depuis le début de la simulation. Si cette méthode est invoquée (nécessairement après une invocation de SetMinOccurrenceClockTime), le moment d'occurrence est calculé par la fonction assignée par SetOccurrenceClockTimeFunction.

otm* OccurrenceTmDate() const
Calcule (et renvoie) la structure tm décrivant la date à laquelle l'événement est prévu.

ovoid SetOccurrenceDate(int, int, int)
Affecte une date à l'événement, en nombre d'unités de temps simulé depuis le début de la simulation. Les arguments sont, dans l'ordre le jour, le mois (ou le ShortMonthName) et le millésime (par exemple 2001). La valeur de l'argument 'millésime' peut être -9. Dans ce cas, le millésime sera supposé être celui de l'horloge de la simulation au moment de l'appel de la méthode.

ovoid SetOccurrenceDate(int, int, int, int, int, int)
Affecte une date à l'événement, en nombre d'unités de temps simulé depuis le début de la simulation. Les arguments sont, dans l'ordre le jour, le mois (ou le ShortMonthName), le millésime (par exemple 2001), l'heure, la minute et la seconde. La valeur de l'argument 'millésime' peut être -9. Dans ce cas, le millésime sera supposé être celui de l'horloge de la simulation au moment de l'appel de la méthode.

ovoid SetRandomizeThisEventClockTime(int (* f)(EventMethod*))
Dote l'événement d'un corps de méthode qui détermine et renvoie le moment aléatoire d'occurrence de l'événement. Le moment est établi entre la date au plus tôt et la date au plus tard. Par défaut d'affectation d'un corps, la date sera déterminée sur la base d'une loi de probabilité uniforme entre les deux bornes. Le moment d'occurence est calculé lors de l'affectation (par SetMaxOccurrenceClockTime) de la borne supérieure (il faut alors que la date au plus tôt ait été spécifiée), puis affecté par SetOccurenceClockTime.

o Processus et directives

ovoid AddProcessAction(Process*, ActionType)
Ajoute un élément en fin du tableau des couples {processus, action\} qui sont la conséquence de l'événement. Lève l'exception UnexpectedAddToListProcessAction.

ovoid AddProcessAction(char*, ActionType)
A le même effet que le service ci-dessus. Le processus est spécifié par un nom de classe : le premier processus trouvé est retenu. Lève l'exception UnfoundProcessForAddingToEvent.

ovoid InsertProcessAction(Process*, ActionType)
Insère un élément en bonne place dans tableau des couples {processus, action\} qui sont la conséquence de l'événement. Cette insertion se fait selon des critères d'ordre définis par la méthode attachée à la simulation par la méthode AssignBeforeInAgendaMethod (classe Simulation). Lève l'exception UnexpectedInsertInListProcessAction.

ovoid InsertProcessAction(char*, ActionType)
A le même effet que le service ci-dessus. Le processus est spécifié par un nom de classe : le premier processus trouvé est retenu. Lève l'exception UnfoundProcessForAddingToEvent.

ovoid DisplayListProcessAction() const
Affiche à l'écran le tableau des couples {processus, action\} qui sont la conséquence de l'occurrence de l'événement.

oStructProcessActionTab ListpProcessAction() const
Renvoie le tableau des couples {processus, action\} qui sont la conséquence de l'occurrence de l'événement.

oint LengthListProcessAction() const
Renvoie le nombre de couples {processus, action\} qui sont la conséquence de l'occurrence de l'événement.

oProcess* FirstProcess()
Renvoie le premier des processus dont le contrôle est une conséquence de l'occurrence de l'événement, ou NULL si aucun processus n'a encore été attaché.

oActionType FirstActionLabel()
Renvoie le type de l'action de contrôle du premier processus lié à l'événement, ou UNSPECIFIED si aucune directive sur processus n'a encore été édictée.

ovoid ClearListProcessAction()
Enlève tous les éléments du tableau des couples {processus, action\} qui sont la conséquence de l'événement.

ovoid DeleteProcesses()
Supprime les processus liés à cet événement (avec leurs méthodes)

o L'entité attachée au(x) processus

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

oBasicEntity* ProcessedBasicEntity(UserProcessId)
Renvoie l'entité sur laquelle le processus dont le symbole de classe est en argument opère un changement d'état. Lève l'exception DoNotHaveProcessedEntity.

oEntity* ProcessedEntity(UserProcessId)
idem avec une entité supposée hériter de la classe Entity

o Spécification des post-conséquences d'un événement
Le message : <event>->SetPostConsequence(f); est normalement envoyé par l'utilisateur dans le constructeur de l'événement. Il affecte à la méthode instance de EventPostConsequence attachée à tout événement un corps f qui sera invoqué par la méthode Run, après le traitement du tableau renvoyé par ListpProcessAction, seulement si tous les processus de cette liste ont vu leurs préconditions satisfaites. La fonction affectée est normalement réalisée dans le fichier UserEvent.cc (en tous cas avant sa première utilisation). Le corps de la fonction f est libre. Son argument est l'instance de EventMethod dont elle est le corps. L'événement lui-même est renvoyé par une invocation de DescribedEvent sur cette instance de EventMethod. Par exemple f peut être :
void MyEventClass_Fct1(EventMethod* pM) { 
  Event* pCurrentEvent = pM->DescribedEvent();
  ...
}

ovoid SetPostConsequence(void (* f)(EventMethod* pM))
Dote l'événement d'un corps de méthode qui code sa post-conséquence.

o Définition de l'événement autogénéré
Un événement est autogénérable si on fait appel, dans son constructeur, au corps de l'un ou l'autre des trois services commentés ci-après. Dans les trois cas, le corps affecté à la méthode appropriée est normalement réalisé dans le fichier UserEvent.cc (en tous cas avant sa première utilisation), et la valeur TRUE est affectée par IsAutoGenerate. La génération d'un nouvel événement à partir d'un autre qui vient d'avoir lieu est alors réalisée dans la méthode Run de Simulation, après le traitement du tableau renvoyé par ListpProcessAction, et après l'invocation éventuelle de la méthode affectée par SetPostConsequence.

ovoid IsAutoGenerate(Boolean)
Spécifie que l'événement possède ou ne possède pas de fonction d'autogénération. La valeur FALSE est attribuée par défaut par le moteur. La valeur TRUE est attribuée lors de l'affectation d'un corps à l'une des méthodes d'autogénération (voir plus loin les méthodes SetGenerateNextEvent, SetDefineNextEventClockTime et SetUpdateNextEvent). Peut aussi être utilisée dans la fonction d'autogénération elle-même avec l'argument FALSE pour inhiber définitivement l'autogénération.

ovoid SetGenerateNextEvent(bool (* f)(EventMethod*))
Dote l'événement d'un corps de méthode qui détermine complètement le nouvel événement (création, avec éventuellement celles des processus associés, et définition des attributs).

ovoid SetUpdateNextEvent(void (* f)(EventMethod*))
Dote l'événement d'un corps de méthode qui modifie le nouvel événement que le moteur s'est chargé de créer.

ovoid SetDefineNextEventClockTime(int (* f)(EventMethod*))
Dote l'événement d'un corps de méthode qui détermine et renvoie la date du nouvel événement. Le moteur crée le nouvel événement et lui affecte (par SetOccurenceClockTime) la date renvoyée.

oEvent* NextEvent() const
Renvoie l'événement suivant autogénéré.

ovoid SetNextEvent(Event*)
Affecte à l'événement qui reçoit ce message l'événement suivant autogénéré. Cette information est utilisée par la méthode Run pour placer le nouvel événement dans l'agenda.

ovoid SetNextEventClassName(char*)
Détermine la classe (par son nom de classe) de l'éventuel événement post généré.

ochar* NextEventClassName() const
Renvoie le nom de la classe de l'éventuel événement post généré.

ovoid SetNextEventOccurrenceProbability(float)
Affecte la probabilité d'occurrence de l'événement généré par l'invocation du corps de méthode affecté par SetGenerateNextEvent ou, par défaut, de l'événement généré par le moteur.

ovoid SetNextEventOccurrenceProbability(int)
Affecte la probabilité d'occurrence de l'événement généré par l'invocation du corps de méthode affecté par SetGenerateNextEvent ou, par défaut, de l'événement généré par le moteur. L'argument doit être entre 0 et 100.

ofloat NextEventOccurrenceProbability() const
Renvoie la probabilité d'occurrence de l'événement généré par l'invocation du corps de méthode affecté par SetGenerateNextEvent ou, par défaut, de l'événement généré par le moteur.

ovoid SetMinDelayNextEvent(int)
Affecte le nombre d'unités de temps minimum avant lequel le prochain événement autogénéré du même type ne peut pas intervenir.

oint MinDelayNextEvent() const
Renvoie le nombre d'unités de temps minimum avant lequel le prochain événement autogénéré du même type ne peut pas intervenir.

ovoid SetMaxDelayNextEvent(int)
Affecte le nombre d'unités de temps maximum au delà duquel le prochain événement autogénéré du même type ne peut pas intervenir.

oint MaxDelayNextEvent() const
Renvoie le nombre d'unités de temps maximum au delà duquel le prochain événement autogénéré du même type ne peut pas intervenir.

ovoid SetRandomizeNextEventClockTime(int (* f)(EventMethod*))
Dote l'événement d'un corps de méthode qui détermine et renvoie le moment aléatoire d'occurrence d'un événement généré automatiquement par la fonction affectée par SetGenerateNextEvent. Par défaut d'invocation de la présente méthode (ou si elle a été définie mais non utilisée dans les méthodes d'autogénération), et si les dates au plus tôt et au plus tard ont été spécifiées, la date sera déterminée sur la base d'une loi de probabilité uniforme entre les deux bornes. L'appel qui réalise ce tirage aléatoire est ExecIntCoreMethod(RANDOMIZE_NEXTEVENTCLOCKTIME).

o Gestion des méthodes spécifiques
Outre les méthodes prédéfinies liées à la postconséquence et à l'autogénération, il est possible de décrire un événement par des méthodes spécifiques, en fonction des besoins de l'application. Il faut alors construire une instance de Method et l'ajouter au tableau des méthodes par une invocation de AddMethod.
int f(EventMethod* pM) {
  int result = 0;
  Event* theEvent = pM->DescribedEvent();
   ...
  return result;
}
MyMethod::MyMethod() {  e.g.  IntEventMethod
  ...
  MyArgument* anArgument = new MyArgument();   e.g. IntArgument
  AddArgument(anArgument);
  AssignBody(f);   reporté dans le constructeur de MyEvent
  ...
}
MyEvent::MyEvent() {
  ...
  MyMethod* aMeth = new MyMethod();
  AssignBody(MY_METHOD, f);
  AddMethod(aMeth);
  ...
}
int main(...) {
  ...
  MyEvent* anEvent = ...;
  SetIntArgValue(MY_METHOD, MY_ARGUMENT, 7); 
  int x = anEvent->ExecIntMethod(MY_METHOD);
  ...
}

Le service AssignBody affecte un corps à une méthode (au sens d'une instance de Method) dont le symbole de classe est donné en premier argument.

Les méthodes ExecVoidMethod, ExecPredicate 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 trois possibilités de type de méthode (void, bool et int), et ces deux possibilités de type d'argument (int et Event*).

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

ovoid AddMethod(Method*)
Ajoute la méthode à la liste des méthodes de l'événement.

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

ovoid AssignBody(UserMethodId, bool (*f)(EventMethod*))

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

ovoid SetIntArgValue(UserMethodId, UserArgumentId, int)

ovoid SetEventArgValue(UserMethodId, UserArgumentId, Event*)

ovoid ExecVoidMethod(UserMethodId)

obool ExecPredicate(UserMethodId)

oint ExecIntMethod(UserMethodId)


Classes descendantes directes :
DiscreteExecution
SetInitialStateAndProceed
SetInitialState
ProceedFromCurrentState

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