Le processus continus de lecture d'un fichier de données séquentielles


o La classe ReadSequentialDataFileProcess
o Corps de méthodes prédéfinies pour la lecture d'un fichier de données séquentielles
Cette sous-classe de processus continu permet d'installer un mécanisme de lecture, enregistrement par enregistrement, d'un fichier de données séquentielles. On rappelle simplement ici que la série d'enregistrements correspond de manière bijective à une série d'intervalles temporels tous de la même longueur (exemple typique : fichier de données climatiques journalières).

Cette installation nécessite la déclaration préalable d'une classe de SequentialDataFile : le processus ne pourra lire que des fichiers physiques qui auront fait l'objet d'une instantiation de cette classe (fichier logique). Le symbole de la sous-classe en question de SequentialDataFile est une propriété du processus de lecture (accessible par FileClassId()).

Sont prédéfinies dans DIESE les méthodes d'initialisation, d'avancée et d'arrêt du processus. C'est la méthode prédéfinie d'initialisation qui instancie le fichier logique SequentialDataFile et l'associe au fichier physique voulu. Pour cela, la méthode exploite complémentairement les informations attachées à la sous-classe de SequentialDataFile et celles attachées au processus de lecture. Les informations sur le fichier sont exploitées en priorité. Elles sont complétées par celles sur le processus. A ce stade seulement, si le nom complet n'a pas été spécifié, il est reconstitué en concaténant le nom du répertoire et le nom simple.

L'initialisation prédéfinie ouvre le fichier en lecture et saute un nombre d'enregistrements égal à la valeur renvoyée par la méthode GetNbTopCommentLines().

Il est important de noter que le développeur peut remplacer la méthode d'initialisation prédéfinie par une autre, plus adaptée à ses besoins. Cela peut être le cas lorsque on souhaite débuter la lecture après ou avant celui de rang immédiatement supérieur à GetNbTopCommentLines(). Cela peut aussi être le cas lorsque le nom du fichier physique est établi selon une règle particulière. Cette situation est rencontrée par exemple lorsque le processus est géré par un événement autogénéré : le fichier à lire peut être différent à chaque lancement du processus et son nom établi selon un algorithmique particulier. Voici le contenu prédéfini de cette méthode, base d'un éventuel surchargement :

void readSequentialDataFileProcess_initializeProcess_Body(ProcessMethod* pM) {
  ReadSequentialDataFileProcess* pCP 
        = (ReadSequentialDataFileProcess*)(pM->DescribedContinuousProcess());
  UserFileId fileClassId = pCP->FileClassId();
  SequentialDataFile* pF 
        = (SequentialDataFile*)pApp_NewSerialDataFileFromId(fileClassId);
  if(! pF)}
    UnknownClassSymbol("SequentialDataFile", fileClassId); // exit(0)
  pCP->SetFile(pF);
  pCP->SetNamesFromFile(pF);
  pCP->AssignFullNameToFile(pF);
  pF->Open();
  pF->Skip(pF->GetNbTopCommentLines());
}

La méthode prédéfinie d'arrêt ne fait que fermer le fichier. Elle peut également être surchargée pour coder des actions particulières lorsque la fin du fichier est rencontrée. Voici son contenu, base d'un éventuel surchargement :

void readSequentialDataFileProcess_stopProcess_Body(ProcessMethod* pM) {
  ReadSequentialDataFileProcess* pCP 
        = (ReadSequentialDataFileProcess*)(pM->DescribedContinuousProcess());
  SequentialDataFile* pF = pCP->GetFile();
  pF->Close();
  pCP->ToBeStopped(TRUE);
}

La méthode prédéfinie d'avancée appelle la méthode ReadNextEnrgt sur l'instance de SequentialDataFile, et la méthode d'arrêt seulement si la fin du fichier est atteinte. Puis, le cas échéant, la méthode qui fait l'objet du paragraphe suivant.

Un processus de cette classe est aussi doté d'une méthode d'exploitation des données contenues dans l'enregistrement qui vient d'être lu sur le fichier physique dans le pas courant du processus (et, on le sait, installés dans les "champs" du fichier logique). Cette méthode n'est pas dotée d'un corps prédéfini. Si le développeur veut l'exploiter, il doit obligatoirement définir et écrire la fonction qui deviendra le corps de la méthode (par un appel à SetPostRead). A titre d'exemple, voici un contenu typique de cette fonction :

void myReadFiles_postReadProcesss_Body(ProcessMethod* pM) {
  ReadSequentialDataFileProcess* pCP 
        = (ReadSequentialDataFileProcess*)pM->DescribedProcess();
  BasicEntity* pE = pCP->ProcessedBasicEntity();
  SequentialDataFile* pF = pCP->GetFile();
  float x = pF->GetFloatFieldValue(FIELD_X);
  // la valeur d'un champ est affectée à un descripteur d'une entité
  pE->SetFloatVarValue(X, x);
  ...
}

On spécifie le fichier que doit lire le processus de l'une des deux manières suivantes :

Pour mettre en oeuvre un processus de cette classe, on l'encapsule, comme c'est la règle générale, dans un événement. Tois possibilités sont offertes :

Dans les trois cas, on peut spécifier le fichier à lire dans le fichier de la structure du système, ou surcharger ces informations si elles ont été placées au niveau du processus ou de la sous-classe de SequentialDataFile.

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