Recapitulação - Cofre Seguro

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 13 de 61.

Desafio

Fácil

Vamos construir um sistema de armário seguro que reúne tudo o que você aprendeu sobre encapsulamento! Seu armário protegerá seu conteúdo atrás de um código secreto — apenas alguém que conheça o código poderá ver o que há dentro.

Você criará dois arquivos para organizar seu código:

locker.rs: Defina uma struct Locker com dois campos privados: code (u32) e contents (String). A struct deve ser pública, mas ambos os campos devem permanecer privados para proteger a segurança do armário. Implemente:
- Um construtor new que recebe um código inicial e o conteúdo
- Um método set_code que permite alterar o código do armário
- Um método get_contents que recebe uma tentativa de código — se corresponder ao código do armário, retorne o conteúdo; caso contrário, retorne "Access denied"
main.rs: Importe seu módulo locker, crie um armário e demonstre seus recursos de segurança tentando acessar o conteúdo com códigos corretos e incorretos.

O método get_contents deve retornar uma String — o conteúdo real quando o código estiver correto, ou a mensagem de negação quando estiver errado. Este é o seu getter condicional que valida o acesso antes de revelar dados privados.

Sua saída deve seguir este formato exato:

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

Por exemplo, se você criar um armário com o código 1234 e o conteúdo "Gold coins", depois tentar o código 0000, alterar o código para 5678 e tentar 5678, a saída seria:

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

Você receberá cinco entradas: o código inicial, o conteúdo, o código da primeira tentativa, o novo código a ser definido e o código da segunda tentativa.

Experimente você mesmo

mod locker;

use locker::Locker;

fn main() {
    // Ler as entradas
    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: Criar um novo Locker com initial_code e contents

    // TODO: Tentar obter contents com o código first_attempt
    // Print: "Attempt with {code}: {result}"

    // TODO: Alterar o código do locker para new_code
    // Print: "Code changed"

    // TODO: Tentar obter contents com o código second_attempt
    // Print: "Attempt with {code}: {result}"
}