Une station météorologique ne se résume pas à une seule mesure.
Au fil des années, elle accumule un ensemble de relevés qu'il sera ensuite possible
d'analyser.
Nous allons maintenant représenter une station météo capable de mémoriser toutes
les mesures qui lui sont associées.
Attention ! La station ne peut enregistrer qu'un seul relevé par an.
Avant d'écrire cette nouvelle structure, réfléchissez aux questions suivantes :
Quelles informations une station météorologique doit-elle mémoriser ?
Quel type de donnée permet de stocker un nombre quelconque de mesures ?
Nous utiliserons un vecteur (
Vec) pour mémoriser les relevés.
Déclarez dans le module
weather_station une structure
WeatherStation contenant
les deux données membres suivantes :
- name, une chaîne de caractères (String) contenant le nom de la station ;
- measurements, un vecteur (Vec<Measurement>) contenant les relevés météorologiques.
Contrairement à
Measurement, cette nouvelle structure représente un objet plus complexe.
Les données membres de
WeatherStation doivent-elles être publiques ? Pourquoi ?
La structure devra être accessible depuis les autres modules, mais ses données
membres resteront encapsulées.
Déclarez ensuite un bloc
impl et fournissez une fonction d'initialisation :
pub fn new(name: String) -> Self
Cette fonction reçoit le nom de la station et crée une station ne contenant encore aucune mesure.
Quelle doit être la taille du vecteur measurements juste après la construction d'une station ?
Testez cette nouvelle structure dans
main().
Créez une station appelée "Brest" puis affichez-la à l'aide de l'affichage de débogage.
Le résultat doit être similaire à :
WeatherStation { name: "Brest", measurements: [] }
Une première difficulté
Vous constaterez que le compilateur refuse probablement d'afficher votre objet.
Pourquoi
Measurement pouvait-il être affiché avec
println!("{:?}", ...),
mais pas encore
WeatherStation ?
Modifiez votre structure afin de permettre son affichage de débogage.
Compilez et exécutez votre programme avant de poursuivre.
Une station météorologique n'a d'intérêt que si elle peut mémoriser les relevés
qui lui sont associés.
Nous allons maintenant permettre d'ajouter progressivement des mesures à une station.
Cette fonctionnalité doit-elle être implémentée comme une fonction membre de
WeatherStation ou comme une fonction indépendante ? Justifiez votre réponse.
Déclarez dans le bloc
impl de
WeatherStation la fonction membre suivante :
pub fn add_measurement(&mut self, measurement: Measurement)
Cette fonction ajoute la mesure reçue en paramètre au vecteur measurements.
Il va de soi qu'elle doit respecter la contrainte d'un seul relevé par an.
Pourquoi le premier paramètre est-il
&mut self et non
&self ?
Dans
main(), créez plusieurs mesures puis ajoutez-les à votre station.
Par exemple :
let mut station = WeatherStation::new("Brest");
station.add_measurement(Measurement{year: 2022, temperature: 13.6, rainfall : 991.0});
station.add_measurement(Measurement{year: 2023, temperature: 14.1, rainfall : 1200.0});
station.add_measurement(Measurement{year: 2024, temperature: 14.3, rainfall : 708.5});
Affichez ensuite la station avec l'affichage de debug structuré
{:#?}.
Le résultat doit être similaire à :
WeatherStation {
name: "Brest",
measurements: [
Measurement { year: 2022, temperature: 13.6, rainfall : 991.0 },
Measurement { year: 2023, temperature: 14.1, rainfall : 1200.0 },
Measurement { year: 2024, temperature: 14.3, rainfall : 708.5 },
],
}
Compilez et vérifiez que toutes les mesures ont bien été ajoutées.
Assurez-vous qu'il ne soit pas possible d'ajouter plusieurs relevés pour la même année.
À ce stade, l'ensemble des données membres de
WeatherStation est privé.
Pourtant, il est déjà possible d'ajouter de nouvelles mesures.
Pourquoi est-il préférable de fournir une méthode
add_measurement() plutôt que
de rendre le vecteur measurements
public ?
Nous pouvons désormais créer une station météorologique et lui ajouter des relevés.
Il est maintenant utile de pouvoir consulter certaines informations sur la station,
comme son nom, le nombre de mesures qu'elle contient ou si elle est vide.
Ajoutez les méthodes suivantes à
WeatherStation :
pub fn name(&self) -> &str
pub fn count(&self) -> usize
pub fn is_empty(&self) -> bool
- name() renvoie le nom de la station ;
- count() renvoie le nombre de mesures actuellement stockées ;
- is_empty() indique si la station ne contient encore aucune mesure.
Modifiez ensuite le programme principal afin d'afficher ces informations.
Par exemple :
Station : Brest
Nombre de mesures : 4
Station vide : false
Compilez et vérifiez que les valeurs affichées correspondent bien à l'état de
votre station.
Nous allons maintenant écrire une méthode permettant d'accéder aux mesures stockées
dans une station.
Contrairement aux méthodes
name(),
count() ou
is_empty(), cette
méthode ne renvoie pas une valeur simple, mais l'ensemble des mesures de la station.
Nous souhaitons toutefois préserver l'encapsulation : le programme principal doit
pouvoir consulter les mesures sans pouvoir les modifier.
Ajoutez à
WeatherStation la méthode suivante :
pub fn measurements(&self) -> &[Measurement]
Cette méthode renvoie une
slice
contenant toutes les mesures de la station.
Une slice est une vue sur une séquence d'éléments.
Contrairement à un
Vec, elle ne possède pas les données et permet simplement d'y accéder.
Le symbole
& indique que la slice est empruntée en lecture seule.
Les mesures restent donc stockées dans la station météorologique.
Pourquoi cette méthode renvoie-t-elle une slice (&[Measurement]) plutôt qu'un
vecteur (
Vec) ?
Testez ensuite votre méthode dans
main().
Par exemple :
let measurements = station.measurements();
println!("Number of measurements: {}", measurements.len());
Vous pourrez ensuite utiliser cette slice avec les fonctions du module
statistics.
Nous souhaitons maintenant utiliser de véritables données météorologiques,
calculées à partir de relevés quotidiens couvrant la période de 1950 à aujourd'hui.
Ces données vous sont fournies dans des fichiers CSV.
Chaque fichier CSV contient les informations suivantes :
year;temperature;rainfall
1950;11.8;991.9
1951;11.6;1116.6
1952;11.6;895.5
...
Nous allons maintenant créer directement une station météorologique à partir
d'un tel fichier.
Cette fonction constitue un deuxième constructeur.
Au lieu de créer une station vide avec
new() puis d'y ajouter les mesures une
à une, elle crée directement une station initialisée à partir du contenu d'un fichier.
Ajoutez à
WeatherStation la fonction associée suivante :
pub fn load(path: &str) -> Result<Self, Box<dyn Error>>
Comme la fonction
new, cette fonction ne possède pas de paramètre
self,
car elle n'agit pas sur une instance existante.
Cette fonction doit :
- ouvrir le fichier CSV ;
- créer une nouvelle station météorologique ;
- lire les mesures contenues dans le fichier ;
- ajouter chaque mesure à la station ;
- renvoyer la station ainsi construite.
Le chargement d'un fichier pouvant échouer (fichier inexistant, erreur de lecture,
données invalides...), cette fonction renvoie un
Result.
Pour implémenter la fonction
load(), inspirez-des exemples fournis dans cette note
Lire un fichier texte
Le chargement d'une station météorologique nécessite de lire un fichier texte
ligne par ligne.
Les quelques exemples suivants rappellent les principales fonctions de la
bibliothèque standard qui seront utiles pour réaliser cette tâche.
Lire le contenu d'un fichier :
use std::fs;
let content = fs::read_to_string("data/brest.csv")?;
// Lit l'intégralité du fichier dans une chaîne de caractères.
// L'opérateur ? propage automatiquement une éventuelle erreur.
Parcourir les lignes :
let mut lines = content.lines();
// Crée un itérateur permettant de parcourir les lignes du fichier.
Ignorer la première ligne :
lines.next();
// Passe à la ligne suivante.
// Ici, on ignore la ligne d'en-tête du fichier CSV.
Parcourir toutes les lignes :
for line in lines {
println!("{}", line);
}
// La variable line contient successivement chaque ligne du fichier.
Découper une ligne. Pour une ligne telle que :
1950;11.8;991.9
on peut écrire :
let mut fields = line.split(';');
// Découpe la ligne selon le caractère ';'.
// fields est un itérateur sur les différentes colonnes.
Lire une colonne :
let year = fields.next().ok_or("missing year")?;
// Extrait la colonne suivante.
// Ici, year est une chaîne de caractères (&str).
// Si l'extraction échoue, l'erreur est propagée grâce à ?.
Convertir une valeur :
let y = year.parse::<u16>()?;
// Convertit la chaîne de caractères en entier.
// Si la conversion échoue, l'erreur est propagée grâce à ?.
Remarque
Pour simplifier ce laboratoire, nous supposerons que les fichiers fournis sont
correctement formatés.
.
Modifiez ensuite le programme principal afin de charger une station depuis le
fichier
brest.csv
Créez un dossier data à la racine
de votre projet, puis placez-y ce fichier.
.
let station = WeatherStation::load("data/brest.csv").unwrap();
Utilisez ensuite les méthodes développées précédemment afin d'afficher :
- le nom de la station ;
- le nombre de mesures.