Breibart/Lankes, Rust-Tutorial, Teil 1

Listing 1: Enum-Beispiel
enum Message {
    Quit,
    Say(String),
    Countdown(i32, i32),
}

fn process_message(m: Message) {
    match m {
      Message::Quit => std::process::exit(0),
      Message::Say(s) => println!("{}", s),
      Message::Countdown(start, end) => {
        for i in end..start {
          println!("{}", i);
        }
      }
    }
}

-----

Listing 2: Traits implementieren
trait Vehicle {
    fn get_speed(&self) -> f32;
    fn get_consumption(&self) -> f32;
}

struct Car {
    speed: f32,
    consumption: f32,
}

impl Vehicle for Car {
    fn get_speed(&self) -> f32 {
      self.speed
    }

    fn get_consumption(&self) -> f32 {
      self.consumption
    }
}

-----

Listing 3: Objekte ausleihen
let mut x = vec!("Hello World!");

{
    let z = &mut x;
    // z benutzen
}

println!("{}", x[0]);

-----

Listing 4: Asynchrones Hello World
use futures::executor::block_on;

async fn hello_world() {
    println!("hello, world!");
}

fn main() {
    let future = hello_world();
    block_on(future);
}

-----

Listing 5: Einfacher Webserver
async fn handle_connection(mut stream: TcpStream) {
    ...
}

async fn http_listen() {
    let listener = TcpListener::bind("127.0.0.1:7878").await.unwrap();
    let mut incoming = listener.incoming();

    // Auf eingehende TCP-Verbindungen auf dem Port 7878 warten
    while let Some(tcpstream) = incoming.next().await {
      handle_connection(tcpstream.unwrap()).await;
    }
}

fn main() {
    block_on(http_listen())
}

-----

Listing 6: Anfragen verarbeiten
async fn handle_connection(mut stream: TcpStream) {
    let get = b"GET / HTTP/1.1\r\n";
    // Einlesen der ersten 1024 Bytes
    let mut buffer = [0; 1024];
    stream.read(&mut buffer).await.unwrap();

    // Abhängig von der Anfrage wird eine Grußnachricht oder
    // eine 404-Fehlerantwort erzeugt.
    let (status_line, filename) = if buffer.starts_with(get) {
          ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
    } else {
        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
    };
    let contents = fs::read_to_string(filename).await.unwrap();

    // Antwort zum Client senden
    let response = format!("{}{}", status_line, contents);
    stream.write(response.as_bytes()).await.unwrap();
    stream.flush().await.unwrap();
}

-----

Listing 7: Die Funktion spawn fertigt einen Thread für asynchrone Anfragen an
async fn http_listen() {
    // Auf den lokalen Port 7878 lauschen und Verbindungen annehmen
    let listener = TcpListener::bind("127.0.0.1:7878").await.unwrap();
    let mut incoming = listener.incoming();

    while let Some(tcpstream) = incoming.next().await {
     async_std::task::spawn(handle_connection(tcpstream.unwrap()));
    }
}
