Riepilogo - Armadietto sicuro

Fa parte della sezione Programmazione orientata agli oggetti del percorso Rust di Coddy. Lezione 13 di 61.

Sfida

Facile

Costruiamo un sistema di armadietto sicuro che riunisce tutto ciò che hai imparato sull'incapsulamento! Il tuo armadietto proteggerà il suo contenuto con un codice segreto: solo chi conosce il codice può vedere cosa c'è dentro.

Creerai due file per organizzare il tuo codice:

locker.rs: Definisci una struct Locker con due campi privati: code (u32) e contents (String). La struct deve essere pubblica, ma entrambi i campi devono rimanere privati per proteggere la sicurezza dell'armadietto. Implementa:
- Un costruttore new che accetta un codice iniziale e un contenuto
- Un metodo set_code che consente di cambiare il codice dell'armadietto
- Un metodo get_contents che accetta un codice tentato; se corrisponde al codice dell'armadietto, restituisce il contenuto; altrimenti, restituisce "Access denied"
main.rs: Importa il modulo dell'armadietto, crea un armadietto e mostra le sue funzionalità di sicurezza provando ad accedere al contenuto con codici corretti e non corretti.

Il metodo get_contents deve restituire una String, che contiene il contenuto effettivo quando il codice è corretto oppure il messaggio di accesso negato quando è errato. Questo è il tuo getter condizionale, che convalida l'accesso prima di rivelare i dati privati.

L'output deve seguire esattamente questo formato:

Attempt with {code}: {result}
Code changed
Attempt with {code}: {result}

Per esempio, se crei un armadietto con il codice 1234 e il contenuto "Gold coins", poi provi il codice 0000, cambi il codice in 5678 e provi 5678, l'output sarà:

Attempt with 0000: Access denied
Code changed
Attempt with 5678: Gold coins

Riceverai cinque input: il codice iniziale, il contenuto, il codice del primo tentativo, il nuovo codice da impostare e il codice del secondo tentativo.

Provalo tu

mod locker;

use locker::Locker;

fn main() {
    // Leggi gli input
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let initial_code: u32 = input.trim().parse().expect("Invalid number");

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let contents = input.trim().to_string();

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let first_attempt: u32 = input.trim().parse().expect("Invalid number");

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let new_code: u32 = input.trim().parse().expect("Invalid number");

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let second_attempt: u32 = input.trim().parse().expect("Invalid number");

    // TODO: Crea un nuovo Locker con initial_code e contents

    // TODO: Prova a ottenere contents usando il codice first_attempt
    // Stampa: "Attempt with {code}: {result}"

    // TODO: Cambia il codice del locker in new_code
    // Stampa: "Code changed"

    // TODO: Prova a ottenere contents usando il codice second_attempt
    // Stampa: "Attempt with {code}: {result}"
}