La classe BufferizedDataFile est une spécialisation de SequentialDataFile incluse dans la couche DIESE. Elle permet de maintenir au cours d'une simulation une structure de données incluant deux types d'information : les valeurs qu'ont prises certaines données séquentielles dans le passé, et des données interprétables comme des predictions sur la valeur que prendront les mêmes données dans le futur.
La compréhension de la présente documentation nécessite de bien connaître la notion de fichier de données séquentielles, présentée dans le chapitre 'Les fichiers de données en série d'enregistrements' de la documentation de la couche BASIC DIESE.
Pour chaque fichier de données, le développeur doit créer une sous-classe de BufferizedDataFile, et insérer dans le code du simulateur la création d'une instance de la sous-classe concernée. La classe BufferizedDataFile posséde par héritage de tous les attributs de SequentialDataFile, plus les attributs spécifiques suivants :
- un tableau de M élements, chacun étant la "copie" d'un enregistrement du fichier séquentiel : celui correspondant à l'instant simulé courant, et M-1 autres pour celui correspondant à l'instant précédent, etc.
- un tableau de P élements, chacun étant la "copie" d'un enregistrement du fichier séquentiel : celui correspondant à l'instant simulé suivant le courant, et P-1 autres pour celui correspondant à l'instant encore suivant, etc. On comprend que le moteur de simulation est amené, pour l'exploitation de ce type de fichier, à "prendre de l'avance" sur les autres processus.
La taille de chacun de ces tableaux est spécifiée dans deux méthodes spécifiques des BufferizedDataFile :
- BFSetMemoryScope, pour laquelle le modélisateur doit coder un corps et l'affecter à la méthode par un appel à \bf AssignSetMemoryScopeMethod}. Ce corps renvoie la taille du tableau de la mémoire sur les instants simulés précédents.
- BFSetPredictionScope, pour laquelle le modélisateur doit coder un corps et l'affecter à la méthode par un appel à \bf AssignSetPredictionScopeMethod}. Ce corps renvoie la taille du tableau de la prédiction sur les instants simulés suivants.
Ces méthodes sont à exploiter, pour la création des deux tableaux, dans l'initialisation du processus continu dédié à la lecture d'un fichier séquentiel de ce type : ReadBufferizedDataFileProcess.
Pour le même processus, la méthode d'avancée exploite la méthode ReadNextEnrgt, héritée de la classe mère SequentialdataFile, mais redéfinie spécifiquement à ce niveau pour tenir compte de l'existence des tableaux de mémoire et de prédiction. En effet, ce n'est plus sur le fichier physique que sont recherchées les valeurs champs pour l'instant courant, mais sur le tableau des prédictions. Plus précisément, l'élément de ce tableau qui représente la prédiction la plus proche est copié dans l'élement du tableau de la mémoire qui représente l'instant courant (par écrasement de l'élement de ce tableau représentant la mémoire la plus lointaine). Ensuite, la méthode ReadNextEnrgt procède à une lecture physique d'un nouvel enregistrement et écrase l'élément du tableau des prédicion représentant la prédiction la plus proche, qui vient de passer en mémoire.
Alors que le corps de la méthode ReadNext d'un SequentialDataFile devait être codé par le modélisateur, le corps de la méthode ReadNext d'un BufferizedDataFile est entièrement prédéfini par le moteur de la couche CONTROL DIESE, pour assurer les tâches ci-dessus. Il reste au modélisateur à coder le corps d'une nouvelle méthode, spécifique des BufferizedDataFile, BFScanNextEnrgt qui scanne l'élément du tableau des prédiction qui représente la prédiction la plus proche. Ce corps a un contenu identique à celui de la méthode ReadNext d'un SequentialDataFile (à structure d'enregistrement identique), à ceci prèe que l'appel à fscanf (lecture du fichier physique) est remplacé par un appel à sscanf (scan d'une chaîne de caractères en mémoire). En reprenant l'example donné dans la documentation des SequentialDataFile, cela donne le code suivant :
int Toboggan_ScanNextEnrgt(BufferizedDataFile* pF, char* str) //--------------------------------------------- // Fonction de scanning d'un enregistrement en mémoire. //--------------------------------------------- { int i; i = sscanf (str, pF->GetFormat(), &pF->mpFieldTab[NUMLIGNE]->mFieldValue.intValue, &pF->mpFieldTab[COMMAND] ->mFieldValue.intValue, &pF->mpFieldTab[VITESSE] ->mFieldValue.floatValue, &pF->mpFieldTab[POSITION]->mFieldValue.floatValue); return i; };... où l'argument str est valué dans le corps de méthode ReadNext avec l'élément approprié du tableau des prédictions.
En résumé, le modélisateur d'un BufferizedDataFile doit :
- créer une sous-classe de SequentialDataFile
- coder et affecter un corps pour les méthodes spécifiant les portéee de la mémoire et de la prédiction
- coder et affecter un corps pour la méthode de scanning d'un enregistrement
Pour des compléments sur le codage du processus de lecture, se reporter au chapitre dédié.