cd $HOME
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

echo "source $HOME/.cargo/env" >> .bashrc
exec bash

rustup toolchain install nightly

username@mordak-pc:~$ rustup show
Default host: x86_64-unknown-linux-gnu
rustup home:  /home/username/.rustup

installed toolchains
--------------------

stable-x86_64-unknown-linux-gnu (default)
nightly-x86_64-unknown-linux-gnu

active toolchain
----------------

stable-x86_64-unknown-linux-gnu (default)
rustc 1.62.0 (a8314ef7d 2022-06-27)

username@mordak-pc:~/Documents/x-exchange$ cat rust-toolchain 
[toolchain]
channel = "nightly-2022-06-14"
# https://rust-lang.github.io/rustup-components-history/

rustup update

rustup target add arm-linux-androideab

rustup doc

username@mordak-pc:~$ echo "fn main() { println!(\"Hello World\"); }" > main.rs 
username@mordak-pc:~$ rustc main.rs 
username@mordak-pc:~$ ./main 
Hello World
username@mordak-pc:~$

username@mordak-pc:/Documents/x-exchange$ cat Cargo.lock
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3

[[package]]
name = "addr2line"
version = "0.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9ecd88a8c8378ca913a680cd98f0f13ac67383d35993f86c90a70e3f137816b"
dependencies = [
 "gimli",
]

[[package]]
name = "adler"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"

...

username@mordak-pc:/Documents/x-exchange$ cat Cargo.toml 
[package]
name = "x-exchange"
version = "0.1.0"
authors = ["mordak & vcombey"]
edition = "2021"

[[bin]]
name = "x-server"
path = "x-server/main.rs"

[[bin]]
name = "ohlc-register"
path = "ohlc-register/main.rs"

[[bin]]
name = "client"
path = "client/main.rs"

[dependencies]
clap = "2.23.0"
lazy_static = "1.4.0"
unixcli = "0.1.3"
rustyline = "6.0.0"
chrono = "0.4.10"
log = "0.4.8"
colored = "2.0.0"
rust_decimal = { version = "1.25.0", features = ["serde-float"] }
lettre = "0.9.3"
regex = "1.4.1"
serde = { version = "1.0.117", features = ["derive"] }
serde_json = "1.0"
dotenv = "0.15.0"
dotenv_codegen = "0.15.0"
aes = "0.6.0"
block-modes = "0.7.0"
hex-literal = "0.3.1"

[features]
fake-token = ["kraken-rust-api/fake-token"]

[dependencies.reqwest]
version = "0.10.8"
features = ["blocking"]

[dependencies.kraken-rust-api]
path = "dependencies/kraken-rust-api"

[dependencies.ta]
path = "dependencies/ta-rs"

[build-dependencies]

[workspace]
members = [
    "dependencies/kraken-rust-api","dependencies/ta-rs",
]

username@mordak-pc:~$ cargo new premier_programme

username@mordak-pc:~$ cd premier_programme/
username@mordak-pc:~/premier_programme$ ls -lR
.:
total 8
-rw-r--r-- 1 username username  186 Jul  2 00:30 Cargo.toml
drwxr-xr-x 2 username username 4096 Jul  2 00:30 src

./src:
total 4
-rw-r--r-- 1 username username 45 Jul  2 00:30 main.rs

username@mordak-pc:~/premier_programme$ cat Cargo.toml 
[package]
name = "premier_programme"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

fn main() {
    println!("Hello, world!");
}

username@mordak-pc:~/premier_programme$ cargo build
   Compiling premier_programme v0.1.0 (/home/username/premier_programme)
    Finished dev [unoptimized + debuginfo] target(s) in 0.56s

username@mordak-pc:~/premier_programme$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/premier_programme`
Hello, world!

username@mordak-pc:~/premier_programme$ cargo run --release
    Finished release [optimized] target(s) in 0.00s
     Running `target/release/premier_programme`
Hello, world!

username@mordak-pc:~/premier_programme$ cargo doc --open

/// La fonction principale de mon programme
fn main() {
    // Write to stdout
    println!("Hello, world!");
}

fn main() {
    // Write to stdout
    println!("Hello, world!");
    /*
    Ce est
    un commentaire
    multiligne
    */
}

mordak@mordak-pc:~/Documents/KFS/rust_kernel$ cat rustfmt.toml
max_width = 120

mordak@mordak-pc:~/premier_programme$ cat -e src/main.rs 
   //! La fonction principale de mon programme$
fn main()    {$
		    // Write to stdout$
    		println!("Hello, world!");                                        $
}$
mordak@mordak-pc:~/premier_programme$ cargo-fmt
mordak@mordak-pc:~/premier_programme$ cat -e src/main.rs 
//! La fonction principale de mon programme$
fn main() {$
    // Write to stdout$
    println!("Hello, world!");$
}$

[dependencies]
colored = "2.0.0"

mordak@mordak-pc:~/premier_programme$ cargo build
    Updating crates.io index
   Compiling libc v0.2.126
   Compiling lazy_static v1.4.0
   Compiling atty v0.2.14
   Compiling colored v2.0.0
   Compiling premier_programme v0.1.0 (/home/mordak/premier_programme)
    Finished dev [unoptimized + debuginfo] target(s) in 16.05s

use colored::Colorize;

/// La fonction principale de mon programme
fn main() {
    // Write to stdout
    println!("{}", "Hello, world!".cyan());
}

fn fibo(n: u32) -> u32 {
    n
}

fn main() {
}

#[cfg(test)]
mod test {
    use crate::fibo;

    #[test]
    fn check_fibonacci() {
        assert_eq!(fibo(1), 1)
    }
}

mordak@mordak-pc:~$ cargo new fibonacci
     Created binary (application) `fibonacci` package

mordak@mordak-pc:~/Documents/fibonacci$ cargo test
   Compiling fibonacci v0.1.0 (/home/mordak/Documents/fibonacci)
    Finished test [unoptimized + debuginfo] target(s) in 0.27s
     Running unittests src/main.rs (target/debug/deps/fibonacci-d72ba84568f68472)

running 1 test
test test::check_fibonacci ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

fn fibo(n: u32) -> u32 {
    n
}

#[cfg(test)]
mod test {
    use crate::fibo;

    #[test]
    fn check_fibonacci() {
        assert_eq!(fibo(1), 1)
    }
}

#[cfg(test)]
mod test {
    use crate::fibo;

    #[test]
    fn check_fibonacci() {
        assert_eq!(fibo(1), 1)
    }
}

    #[test]
    fn check_fibonacci() {
        assert_eq!(fibo(1), 2)
    }

    let a: u32 = 42;
    let b: i64 = -127;
    let c: isize = -128;
    let pi: f32 = std::f32::consts::PI;
    let pi: f64 = std::f64::consts::PI;

    let b: bool = false;
    let c: bool = true;

    let b: bool = 0;
    let c: bool = 1;

    let mut b: bool = false;
    if !b {
        println!("B is false");
    }
    b = true;
    if b {
        println!("B is true");
    }
    let c: bool = true;
    if b & c {
        println!("B and C are true")
    }

    let c: char = 't';
    println!("len: {} - {}", c.len_utf8(), c);
    let c: char = 'ф';
    println!("len: {} - {}", c.len_utf8(), c);
    let c: char = '錆';
    println!("len: {} - {}", c.len_utf8(), c);

len: 1 - t
len: 2 - ф
len: 3 - 錆

    fn mul(n: (u32, f64), e: u32) -> (u32, f64) {
        (n.0 * e, n.1 * e as f64)
    }
    let g = mul((42, std::f64::consts::PI), 2);    
    dbg!(g);

[src/main.rs:60] g = (
    84,
    6.283185307179586,
)

    type Tuple = (u32, f64);
    fn mul2(n: Tuple, e: u32) -> Tuple {
        (n.0 * e, n.1 * e as f64)
    }
    let g = mul2((42, std::f64::consts::PI), 2);    
    dbg!(g);

    let g = mul2(Tuple(42, std::f64::consts::PI), 2);    
    dbg!(g);

    // Les types ne sont pas declares ici
    let mut a = (42, 1.25);
    fn mul3(n: (u32, f64), e: u32) -> (u32, f64) {
        (n.0 * e, n.1 * e as f64) 
    }
    a = mul3(a, 2);
    dbg!(a);

    fn mul4(n: (u32, f32), e: u32) -> (u32, f32) {
        (n.0 * e, n.1 * e as f32) 
    }
    a = mul4(a, 2);
    dbg!(a);

    let a: u32 = 42;
    a += 1;

    let mut a: u32 = 42;
    dbg!(a);
    return;

static PORT1: u32 = 8080;
const PORT2: u32 = 8443;

fn dump_ports() {
    println!("Port1: {}", PORT1)
    println!("Port2: {}", PORT2)
}

Port1: 8080
Port2: 8443

static mut PORT: u32 = 8080;

fn change_port() {
    PORT = 8443;
}

Port1: 8080
Port2: 8443

static mut PORT: u32 = 8080;

fn change_port() {
    unsafe {
        PORT = 8443;
    }
}

let a = true;
let b = a;
dbg!(a);
dbg!(b);
let a = (std::f32::INFINITY, std::f32::INFINITY);
let b = a;
dbg!(a);
dbg!(b);

let banane: String = "Banane".into();
let deuxieme_banane = banane;
dbg!(banane);
dbg!(deuxieme_banane);

let banane: String = "Banane".into();
let deuxieme_banane = banane.clone();
dbg!(banane);
dbg!(deuxieme_banane);

#[derive(Clone)]
struct Remote {
    ipv4: (u8, u8, u8, u8),
    port: u32,
    server_name: String,
}
let r1 = Remote {
    ipv4: (192, 168, 41, 1),
    port: 8080,
    server_name: "xp6".into(),
};
let r2 = r1.clone()

fn main() {
    let n: u32 = 11 - 3;
    if n == 8 {
        println!("8");    
    } else if (n > 8) {
        println!(">8: {}", n)
    } else {
        println!("<8: {}", n)
    }
    let a = true;
    if n == 8 && a == true {
        println!("8 et a: true");    
    }
}

fn main() {
    let n: u32 = 11 - 3;
    if n == 8 {
        println!("8");    
    } else if n > 8 {
        println!(">8: {}", n)
    } else println!("<8: {}", n);
    let a = true;
    if n == 8 && a == true {
        println!("8 et a: true");    
    }
}

fn main() {
    let mut count = 0u32;

    println!("Let's count until infinity!");
    // Infinite loop
    loop {
        count += 1;
        if count == 3 {
            println!("three");
            // Skip the rest of this iteration
            continue;
        }
        println!("{}", count);
        if count == 5 {
            println!("OK, that's enough");
            // Exit this loop
            break;
        }
    }
}

fn main() {
    // A counter variable
    let mut n = 1;

    // Loop while `n` is less than 101
    while n < 101 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }

        // Increment counter
        n += 1;
    }
}

#include <stdio.h>
int main(void) {
    for (int i = 0; i < 10; i++) {
        printf("%i\n", i);
    }
    return 0;
}

fn main() {
    for i in 0..10 {
        println!("{}", i);
    }
}

#include <stdio.h>
int main(void) {
    for (int i = 0; i < 10; i += 2) {
        printf("%i\n", i);
    }
    return 0;
}

fn main() {
    for i in (0..10).step_by(2) {
        println!("{}", i);
    }
}

fn main() {
    let fizzbuzz = ["Fizz", "Buzz", "FizzBuzz"];
    // Creation d'un iterateur sur l'array
    let iter = fizzbuzz.iter();
    // On utilise une refence ici pour ne pas 'move'
    // par erreur l'iterateur, un iterateur n'est pas Copy
    dbg!(&iter);
    for word in iter {
        println!("{}", word);
    }
}

[src/main.rs:32] &iter = Iter(
    [
        "Fizz",
        "Buzz",
        "FizzBuzz",
    ],
)
Fizz
Buzz
FizzBuzz

fn main() {
    // On declare une chaine de caractere
    // Elle ne contient que des chiffres
    let a = "1637";
    let res = a.parse::<u32>();
    // eq: let res: Result<u32, _> = a.parse(); cf turbofish
    dbg!(number);

    // Ici, une chaine comppsee de chiffre et de lettre
    let b = "16cents trente-sept";
    let res = b.parse::<u32>();
    dbg!(res);
}

pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>
where
    F: FromStr, 

[src/main.rs:35] res = Ok(
    1637,
)
[src/main.rs:40] res = Err(
    ParseIntError {
        kind: InvalidDigit,
    },
)

fn main() {
    // Ici, une chaine comppsee de chiffre et de lettre
    let b = "16cents trente-sept";
    let result = b.parse::<u32>();
    dbg!(&result);

    if let Ok(number) = result {
        println!("result: {}", number);
    }
    if let Err(err) = result {
        println!("error: {}", err);
    }
}

fn main() {
    let b = "16cents trente-sept";
    let result = b.parse::<u32>();
    if let Err(error) = result {
        println!("Sorry, but an error has occured: {}", error);
        return;
    }
}

fn main() {
    // Ici, une chaine comppsee de chiffre et de lettre
    let b = "16cents trente-sept";
    let number = b.parse::<u32>().unwrap();
    dbg!(number);
}

thread 'main' panicked at 'called `Result::unwrap()` on an `Err`
value: ParseIntError { kind: InvalidDigit }', src/main.rs:83:35
note: run with `RUST_BACKTRACE=1` environment variable to display
a backtrace

pub fn expect(self, msg: &str) -> T
where
    E: Debug, 

fn main() {
	let a = [1, 2, 3];

	let mut iter = a.iter();

	// A call to next() returns the next value...
	assert_eq!(Some(&1), iter.next());
	assert_eq!(Some(&2), iter.next());
	assert_eq!(Some(&3), iter.next());

	// ... and then None once it's over.
	assert_eq!(None, iter.next());
}

fn main() {
    let a: Option<u32> = Some(11);
    if let Some(value) = a {
        println!("{}", value)
    }
    if let None = a {
        println!("None");
    }
}

fn main() {
    let b = "16cents trente-sept";
    let result = b.parse::<u32>();
    match result {
        Ok(number) => println!("{}", number),
        Err(error) => {
            eprintln!("error: {}", error);
            panic!("Je veux que le programme panic!");
        }
    }
}

error: invalid digit found in string
thread 'main' panicked at 'Je veux que le programme panic!',
src/main.rs:88:13
note: run with `RUST_BACKTRACE=1` environment variable to
display a backtrace

fn main() {
    let b = "16cents trente-sept";
    let result = b.parse::<u32>();
    match result {
        Ok(number) => println!("{}", number),
    }
}

fn main() {
    let b = "16cents trente-sept";
    let result = b.parse::<u32>();
    match result {
        Ok(number) => println!("{}", number),
        _default => {},
    }
}

fn main() {
    enum Target {
        X86(u32),
        Ia32(u32),
        Mips,
    }
    use Target::*;
    let my_target = Ia32(25);
    match my_target {
        X86(freq) => println!("X86 at frequency {} mhz", freq),
        Ia32(_) => println!("Ia32 but we dont worried about frequency"), 
        Mips => println!("Just an other Mips again"), 
    }
}

fn main() {
    let tuple: (u8, u8, u8, u8, u8) = (0, 1, 1, 2, 3);
    // destructured tupple
    match tuple {
        (0..=5, .., v5) => println!("v5 = {}", v5),
        (6..=u8::MAX, .., v4, v5) => println!("v4 = {} v5 = {}", v4, v5),
    }
}

fn main() {    
    let v: u32 = 142;
    match v {
        i if i < 100_u32 => println!("Below than 100: {}", i),
        i if i >= 100_u32 => println!("Above or equal than 100: {}", i),
        _ => panic!("WOOT ?"),
    }
}

fn main() {
    use std::env;

    // Prints each argument on a separate line
    for argument in env::args() {
        println!("argument: {}", argument);
    }
}

fn main() {
    use std::env;

    let args = env::args();
    dbg!(args.len());
}

use std::env;

fn main() {
    let arguments: Vec<String> = env::args().collect();
    dbg!(&arguments);
    if arguments.len() != 2 {
        eprintln!("Usage: {} POSITIF_NUMBER", arguments[0]);
        return;
    }
    let argument = arguments[1].parse::<u32>().unwrap();
    println!("le nombre est {}", argument);
}

mordak@mordak-pc:~/Documents/fibonacci$ cargo run 99933
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/fibonacci 99933`
[src/main.rs:8] &args = [
    "target/debug/fibonacci",
    "99933",
]
le nombre est 99933

mordak@mordak-pc:~/Documents/fibonacci$ cargo run 99933ggg
   Compiling fibonacci v0.1.0 (/home/mordak/Documents/fibonacci)
    Finished dev [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/fibonacci 99933ggg`
[src/main.rs:8] &args = [
    "target/debug/fibonacci",
    "99933ggg",
]
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }', src/main.rs:13:43
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

// recursive function
unsigned int fibo(unsigned int n) {
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        return fibo(n - 1) + fibo(n - 2);
    }
}

use std::env;

fn fibo(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibo(n - 1) + fibo(n - 2),
    }
}

fn main() {
    let arguments: Vec<String> = env::args().collect();
    if arguments.len() != 2 {
        eprintln!("Usage: {} POSITIF_NUMBER", arguments[0]);
        return;
    }
    match arguments[1].parse::<u32>() {
        Ok(number) => println!("Fibonacci of {} -> {}", number, fibo(number)),
        Err(err) => eprintln!("Bad number format: {}", err),
    }
}

#[cfg(test)]
mod test {
    use super::fibo;

    #[test]
    fn check_fibonacci() {
        let sequence = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144];
        for (i, result) in sequence.into_iter().enumerate() {
            assert_eq!(result, fibo(i as u32));
        }
    }
}

mkdir dependencies
cd dependencies
cargo new --lib ma-lib

dependencies/:
total 4
drwxr-xr-x 3 mordak mordak 4096 Jul  5 03:24 ma-lib

dependencies/ma-lib:
total 12
-rw-r--r-- 1 mordak mordak  153 Jul  5 03:22 Cargo.lock
-rw-r--r-- 1 mordak mordak  178 Jul  5 03:17 Cargo.toml
drwxr-xr-x 2 mordak mordak 4096 Jul  5 03:17 src

dependencies/ma-lib:
total 4
-rw-r--r-- 1 mordak mordak 216 Jul  5 03:17 lib.rs

[dependencies.ma-lib]
path = "dependencies/ma-lib"

pub fn add(left: usize, right: usize) -> usize {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

[src/main.rs:4] add(42, 42) = 84

use interface::add;

fn main() {
    dbg!(add(42, 42));
}

use ma-lib::operations::test;

pub mod operations;

use ma-lib::sub;

mod operations;
pub use uperations::sub;

use ma-lib::{add, sub};

fn main() {    
    #[derive(Debug)]
    enum Error {
        FileNotFound,
        BadFormat,
        Unexpected,
    }
    let my_error = Error::Unexpected;
    dbg!(&my_error);
    use Error::*;
    match my_error {
        FileNotFound => {}
        BadFormat => {}
        Unexpected => {}
    }
}

fn main() {
    #[derive(Debug)]
    #[repr(u32)]
    enum Error {
        FileNotFound = 0,
        BadFormat,
        Unexpected,
    }
    let my_error = Error::FileNotFound;
    if my_error as u32 == 0 {
        println!("C'est bien FileNotFound");
    }
}

fn main() {
    #[derive(Debug)]
    enum Voiture<T> {
        Lada(T),
        Wolkswagen(T),
        Peugeot(T),
    }
    let v1 = Voiture::Lada(100_u32);
    let mut v2 = Voiture::Wolkswagen(1000_usize);
    v2 = Voiture::Lada(4200_usize);
    dbg!(v2);
}

    use Voiture::{Lada, Peugeot};
    let mut v3 = Peugeot(12_u8);
    v3 = Lada(42_u32);
    dbg!(v3);

fn main() {
    #[derive(Debug, Clone)]
    struct Remote {
        ipv4: (u8, u8, u8, u8),
        port: u32,
        name: String,
    }
}

#[derive(Debug, Clone)]
struct Remote {
    ipv4: (u8, u8, u8, u8),
    port: u32,
    name: String,
}

#[derive(Debug, Clone)]
struct Vector {
    i: i32,
    j: i32,
}

// Ici, les identifiants du prototype de la fonction sont les memes
// que ceux de la structure.
fn get_vector(i: i32, j: i32) -> Vector {
    Vector {
        i,
        j,
    }
}

fn main() {
    let r = Remote{
        ipv4: (192, 168, 12, 4),
        port: 3212,
        name: String::from("vbx"),
    };
    dbg!(r);
    let v = get_vector(1, -1);
    dbg!(v);
}

    impl Remote {
        fn new(ipv4: (u8, u8, u8, u8), port: u32, name: &str) -> Self {
            Self {
                ipv4,
                port,
                name: name.into(),
            }
        }
        fn get_addr(&self) -> String {
            format!(
                "{}.{}.{}.{}:{}",
                self.ipv4.0, self.ipv4.1, self.ipv4.2, self.ipv4.3, self.port
            )
        }
        fn change_port(&mut self, new_port: u32) {
            self.port = new_port;
        }
    }

    impl Drop for Remote {
        fn drop(&mut self) {
            println!("Droping remote")
        }
    }

    fn drop_remote(remote: Remote) {}
    let mut s = Remote::new((0, 0, 0, 0), 443, "Space");
    dbg!(&s);
    s.change_port(80);
    dbg!(&s);
    drop_remote(s);
    println!("after call");

use std::ptr;

int main() {
    let mut a: u32 = 42;
    let ptr: *const u32 = &mut a;
    dbg!(ptr);
    // Easy
    unsafe {
        dbg!(*ptr);
    }
    let prim: [u32; 6] = [2, 3, 5, 7, 11, 13];
    let ptr: *const u32 = prim.as_ptr();
    // We now what we are doing (for the moment...)
    unsafe {
        dbg!(*ptr);
        dbg!(*ptr.offset(1));
        dbg!(*ptr.offset(2));
        dbg!(*ptr.offset(3));
        dbg!(*ptr.offset(4));
        dbg!(*ptr.offset(5));
    }
    // This block may lead to Segmentation fault
    unsafe {
        dbg!(*ptr.offset(66224411));
    }
}

[src/main.rs:17] ptr = 0x00007fffa4eaef94
[src/main.rs:20] *ptr = 42
[src/main.rs:26] *ptr = 2
[src/main.rs:27] *ptr.offset(1) = 3
[src/main.rs:28] *ptr.offset(2) = 5
[src/main.rs:29] *ptr.offset(3) = 7
[src/main.rs:30] *ptr.offset(4) = 11
[src/main.rs:31] *ptr.offset(5) = 13
Segmentation fault

int main() {
    int x = 10;
    int &r = x;             // initialization creates reference implicitly
    assert(r == 10);        // implicitly dereference r to see x's value
    r = 20;                 // stores 20 in x, r itself still points to x
}

fn main() {
    let x = 10;
    let r = &x;             // &x is a shared reference to x
    assert!(*r == 10);      // explicitly dereference r
}

fn main() {
    let x: u32 = 10;
    let r: &u32 = &x;       // &x is a shared reference to x
    assert!(*r == 10);      // explicitly dereference r
}

fn main() {
    let mut j: u32 = 10;
    let r: &mut u32 = &mut j;
    *r *= 20;
    dbg!(j);
}

int main() {
    let a = 16;
    let b = 16;
    let ra = &a;
    let rb = &b;
    assert_eq!(ra, rb);
    assert_eq!(*ra, *rb);
    assert_eq!(&ra, &rb);
    assert_eq!(&&ra, &&rb);

    // Ne compile pas: comparaison entre &integer et integer
    // assert_eq!(*ra, rb);
}

fn main() {
    fn dump_string(s: &String) {
        println!("{}", s);
    }
    let mut s: String = "banane".into();
    dump_string(&s);
    s.clear();
    dump_string(&s);
}

#[derive(Debug, Copy, Clone)]
struct Vector {
    i: i32,
    j: i32,
}

impl Vector {
    fn add_assign(&mut self, other: Self) {
        self.i += other.i;
        self.j += other.j;
    }
}

fn main() {
    let v = Vector{i: 10, j: -3};
    dbg!(v);
    v.add_assign(Vector{i: 2, j: 4});
    dbg!(v);
}

    (&mut v).add_assign(Vector{i: 2, j: 4});

    let mut num = 5;
    let numRef = &mut num;

fn main() {
    let mut num = 5;
    let numRef = &mut num;
    dbg!(num);
    *numRef = 6;
}

    let mut num = 5;
    let numRef = &mut num;

     dbg!(num);

    *numRef = 6;

fn main() {
    let mut num = 5;
    let numRef = &mut num;
    dbg!(*numRef);
    *numRef = 6;
}

struct A {
    r: &i32,
}

struct A {
    r: &'static i32,
}

struct A<'a> {
    r: &'a i32,
}

#[derive(Debug)]
struct A<'a> {
    i: &'a i32,
}
    

fn main() {
    let r: A;
    {
        let i: i32 = 42;
        r = A{
            i: &i
        };
    }
    dbg!(r);
}

pub struct Box<T, A = Global>(_, _) 
where
    A: Allocator,
    T: ?Sized;

struct Vector {
    i: i32,
    j: i32,
}

fn main() {
    let vec = Box::new(Vector{ i: 10, j: -5});
}

fn make_box(vec: Vector) -> Box<Vector> {
    Box::new(vec)
}

fn take_box(b: Box<Vector>) {
    // La box ne vivra plus a la fin du ce bloc
}

fn main() {
    let b = make_box(Vector{ i: 10, j: -20});
    // Ici la box vit
    dbg!(&b);
    take_box(b);
    // A ce point du code, la box a deja ete liberee
}

fn main() {
    let mut v = Vector{i: 9, j: -3};
    v.i = 87;
    v,j = -12;
    let mut b = Box::new(Vector{i: 10, j: -20});
    b.i = 12;
    b.j = -11;
}

fn main() {
    // A partir d'un vecteur vide
    let mut v1 = Vec::new();
    v1.push(1);
    v2.push(2);
    v3.push(3);
    // A partir d'un tableau
    let mut v2 = [1, 2, 3].to_vec();
    // A partir de la macro vec!
    let mut v3 = vec!(1, 2, 3);
}

fn main() {
    // A partir d'un vecteur vide
    let mut v1: Vec<u64> = Vec::new();
    v1.push(1);
    v1.push(2);
    // Utilisation ici de la syntaxe literale pour definir un type
    v1.push(3_u64);
    // A partir d'un tableau
    let mut v2: Vec<u8> = [1, 2, 3].to_vec();
    // A partir de la macro vec!
    let mut v3: Vec<u32> = vec!(1, 2, 3);
    // Utisation du turbofish ::<>
    let mut v4 = Vec::<u64>::new();
    v4.push(1);
    v4.push(2);
    v4.push(3_u64);
}

fn main() {
    // A partir d'un vecteur vide
    let mut v1: Vec<u64> = Vec::new();
    v1.push(1);
    v1.push(2);
    // Utilisation ici de la syntaxe literale pour definir un type
    v1.push(3_u64);
    dbg!(v1[0]);                                                                                                                       
    dbg!(v1[1]);                                                                                                                       
    dbg!(v1[2]);
    // PANIC
    dbg!(v1[3]);
}

fn main() {
    // A partir d'un vecteur vide
    let mut v1: Vec<u64> = Vec::new();
    v1.push(1);
    v1.push(2);
    // Utilisation ici de la syntaxe literale pour definir un type
    v1.push(3_u64);
    dbg!(v1.get(0));                                                                                                                       
    dbg!(v1.get(1));                                                                                                                       
    dbg!(v1.get(2));
    // Retourne None
    dbg!(v1.get(3));
}

fn main() {
    let mut v = Vec::<u64>::new();
    // Ajoute 10 a la fin de la colletion
    v.push(10);
    // Retire le dernier element de la collection
    // et retoune une Option de celui-ci
    dbg!(v.pop());
    let mut v2: Vec<u64> = vec![4, 5, 6];
    // Copie les valeurs de v2 dans v1, vide v2
    v.append(&mut v2);
    // Vide la collection
    v.clear();
    // Itere sur le vecteur et dump les valeurs contenues
    v.iter().for_each(|v| {
        dbg!(v);
    });
    // Itere de facon mutable sur le vecteur, modifie ses valeurs
    v.iter_mut().for_each(|value| {                                                                                                       
        *value *= 2;                                                                                                                        
    });
}

int main() {
    let mut s: String = String::new();
    s.push_str("Hello");
    dbg!(&s);
    s.push(' ');
    s.push_str("World");
    dbg!(&s);
    s.clear();
    dbg!(&s);
}

int main() {
    let s: String = "Hello World".into();
    dbg!(s);
    let mut s = String::from("Hello World");
    dbg!(&s);
    s = "Nouvelle chaine".into();
    dbg!(s);
}

int main() {
    let f = String::from("Hello") + " World".into();
    dbg!(f);
}

int main() {
    use std::sync::Arc;                                                                                                                 
    #[derive(Debug)]                                                                                                                    
    struct Vector {                                                                                                                     
        i: u32,                                                                                                                         
        j: u32,                                                                                                                         
    }                                                                                                                                   
    // Creation de l'Arc, le reference Counter passe a 1                                                                                
    let a = Arc::<Vector>::new(Vector {i: 12, j: 42});                                                                                  
    {                                                                                                                                   
        // Creation du clone, le reference Counter passe a 2                                                                            
        let b = a.clone();                                                                                                              
        // Passage par reference, le clone n'est pas detruit lors de l'appel                                                            
        dbg!(&b);                                                                                                                       
        // Ici le clone est detruit -> Fin du bloc d'instruction                                                                        
        // Le reference Counter repasse a 1                                                                                             
    }                                                                                                                                   
    // L'arc est envoye a la fonction dbg!, il est ainsi detruit apres le retour                                                        
    // de la fonction dbg! puisque son reference Counter passe a 0.                                                                     
    dbg!(a);
}

fn main() {
    let mut data: i32 = 42;
    let _t = std::thread::spawn(move || {
        dbg!(data);
        data = 11;
        dbg!(data);
    });
    data = 22;
    dbg!(data);

    let mut s: String = "42".to_owned();
    let _t = std::thread::spawn(move || {
        dbg!(&s);
        s.push_str("11");
        dbg!(&s);
    });
    s.push_str("22");
    dbg!(&s);   
}

use std::sync::mpsc;
use std::thread::ThreadId;

#[derive(Debug, Copy, Clone)]
enum Event {
    Hello,
    HelloAgain,
    IWantToStop,
}

fn main() {
    let (sender, receiver): (
        mpsc::Sender<(Event, ThreadId)>,
        mpsc::Receiver<(Event, ThreadId)>,
    ) = mpsc::channel();
    let sender2 = sender.clone();
}

let _happy_thread = thread::spawn(move || { 
})


let _bad_thread = thread::spawn(move || { 
})

            sender
                .send((Event::HelloAgain, thread::current().id()))
                .unwrap();

loop {
    let (msg, id) = receiver.recv().unwrap();
    // if condition, break
}

            sender2
                .send((Event::Hello, thread::current().id()))
                .unwrap();

panic!("sa mere");

use std::sync::mpsc;
use std::thread::ThreadId;
use std::{thread, time};

#[derive(Debug, Copy, Clone)]
enum Event {
    Hello,
    HelloAgain,
    IWantToStop,
}

fn main() {
    let (sender, receiver): (
        mpsc::Sender<(Event, ThreadId)>,
        mpsc::Receiver<(Event, ThreadId)>,
    ) = mpsc::channel();
    let sender2 = sender.clone();

    let three_seconds = time::Duration::from_millis(3000);

    let _happy_thread = thread::spawn(move || {
        sender.send((Event::Hello, thread::current().id())).unwrap();
        loop {
            thread::sleep(three_seconds);
            sender
                .send((Event::HelloAgain, thread::current().id()))
                .unwrap();
        }
    });

    let _bad_thread = thread::spawn(move || {
        sender2
            .send((Event::Hello, thread::current().id()))
            .unwrap();
        thread::sleep(three_seconds * 3);
        sender2
            .send((Event::IWantToStop, thread::current().id()))
            .unwrap();
        panic!("sa mere");
    });

    loop {
        let (msg, id) = receiver.recv().unwrap();
        println!("message recu: {:?} de {:?}", msg, id);
        if let Event::IWantToStop = msg {
            println!("A thread want to stop");
            break;
        }
    }
    println!("Exiting Main thread normallu. Bye");
}

fn main {
    // Tous les types contenus ici sont Send                                                                                               
    #[derive(Debug)]                                                                                                                    
    struct S {                                                                                                                          
        i: u8,                                                                                                                          
        j: u8,                                                                                                                          
        k: String,                                                                                                                      
    }                                                                                                                                   
    let s = S {                                                                                                                         
        i: 1,                                                                                                                           
        j: 2,                                                                                                                           
        k: "toto".to_string(),                                                                                                          
    };                                                                                                                                  
    let _t = std::thread::spawn(move || {                                                                                               
        dbg!(s);                                                                                                                        
    });
}

fn main {
    // Un pointeur en rust n'est pas Send
    #[derive(Debug)]
    struct S2 {
        ptr: *const u8,
    }
    let s2 = S2 {
        ptr: std::ptr::null(),
    };
    let _t = std::thread::spawn(move || {
        dbg!(s2);
    });
}

    unsafe impl Send for S2

use std::num::ParseIntError;

fn parse_all(a: &str, b: &str, c: &str) -> Result<u32, ParseIntError> {
    let r1: u32 = a.parse::<u32>()?;
    dbg!(r1);
    let r2: u32 = b.parse::<u32>()?;    
    dbg!(r2);
    let r3: u32 = c.parse::<u32>()?;    
    dbg!(r3);
    Ok(r1 + r2 + r3)
}

fn main() {
    match parse_all("1637", "42", "toto21") {
        Ok(res) => println!("La somme vaut {}", res),
        Err(err) => println!("Erreur: {}", err),
    }
    println!("Hello, world!");
}

    let r3 = match c.parse::<u32>() {
        Ok(res) => res,
        Err(e) => return Err(e),
    };

    let r3 = c.parse::<u32>()?;

   let total = v.iter().fold(0, |total, next| total + next);

    let mut total = 0;
    for i in 0..v.len() {
        total += v[i];
    }

let squared: Vec<u32> = (1..10).map(|x| x * x).collect();

fn main() {
    let mut v: Vec<u8> = vec!(1, 2, 4, 8);
    v.iter_mut().for_each(|inner| *inner *= 2);
    dbg!(&v);
}

fn main() {
    // Declaration de la variable s en dehors de la closure
    let s = "MaString".to_string();
    // Ici on definit la closure avant de l'utiliser
    let closure = |inner: &mut u8| {
        *inner *= 2;
        // Ici la variable s est capturee par reference &s
        println!("One other iteration: {}", s);
    };
    let mut v: Vec<u8> = vec!(1, 2, 4, 8);
    v.iter_mut().for_each(closure);
    // s est toujours accessible ici
    dbg!(&s);

    // Ici la closure est anonyme
    v.iter_mut().for_each(|inner| {
        *inner *= 2;
        // Ici la variable s est capturee par reference &s
        println!("One other iteration: {}", s);
    });
    // s est toujours accessible ici
    dbg!(&s);
}

fn main() {
    // Declaration de la variable s en dehors de la closure
    let s = "MaString".to_string();
    // Ici on definit la closure avec MOVE avant de l'utiliser
    let closure = move |inner: &mut u8| {
        *inner *= 2;
        // Ici, l'ownership de la variable s est passe au thread
        println!("One other iteration: {}", s);
    };
    v.iter_mut().for_each(closure);
    // s n'est plus accessible ici, le programme ne compile donc pas !
    dbg!(s);
}

fn main() {
    let mut v: Vec<u8> = vec!(1, 2, 4, 8);
    v.iter_mut().for_each(|inner| *inner *= 2);
    dbg!(&v);
}

fn main() {
    let mut v: Vec<u8> = vec!(1, 2, 4, 8);
    v.iter_mut().enumerate().for_each(|(index, inner)| {
        if index == 0 {
            v.push(16);
        }
        *inner *= 2;
    });
    dbg!(&v);
}

fn main() {
    #[derive(Debug)]
    struct S {
        i: i32,
        j: i32,
    }
    let mut s = S {
        i: -1,
        j: -2,
    };
    let ref_i = &mut s.i;
    let ref_s = &mut s;
    *ref_i = -11;
    dbg!(s);
}

    let ref_i = &mut s.i;
    let ref_j = &mut s.j;
    *ref_i = -11;
    *ref_j = -12;
    *ref_i = -21;
    *ref_j = -22;
    dbg!(s);

unsafe {
    print!("{:#04x} ", *ptr.offset(byte as isize));
}

pub trait HexDump {
    fn hex_dump(&self);
}

impl HexDump for u32 {
    fn hex_dump(&self) {}
}

impl <T>HexDump for T {
    fn hex_dump(&self) {}
}

pub trait HexDump {
    fn hex_dump(&self);
}

impl<T> HexDump for T {
    fn hex_dump(&self) {
        let ptr = std::ptr::addr_of!(*self) as *const u8;
        for byte in 0..std::mem::size_of::<Self>() {
            unsafe {
                print!("{:#04x} ", *ptr.offset(byte as isize));
            }
        }
        println!();
    }
}

fn main() {
    let r: u32 = 42;
    r.hex_dump();
    let r: u32 = 0;
    r.hex_dump();
    let r: f64 = 42.12;
    r.hex_dump();
}

fn main() {
    fn first_element(slice: &[u8]) -> &u8 {
        &slice[0]
    }
    let v = vec![1, 2, 3];
    dbg!(first_element(v));
}

fn main() {
    fn first_element<'a>(slice: &'a [u8]) -> &'a u8 {
        &slice[0]
    }
    let v = vec![1, 2, 3];
    dbg!(first_element(v));
}

fn main() {
    struct MaStruct {
        inner_a: u32,
        inner_b: u32,
    }
    fn get_inner_a(t: &MaStruct) -> &u32 {
        &t.inner_a
    }
    fn get_inner_a_by_rust<'a'>(t: &'a MaStruct) -> &'a u32 {
        &t.inner_a
    }
}

    impl MaStruct {
        fn get_inner_a(&self) -> &u32 {
            &self.inner_a
        }
    }

    impl MaStruct {
        fn get_inner_a<'a>(&'a self) -> &'a u32 {
            &self.inner_a
        }
    }

    fn dump_a_string_and_get_inner_a(t: &MaStruct, s: &str) -> &u32 {                                                                          
        println!("{}", s);                                                                                                              
        &t.inner_a                                                                                                                      
    }

    fn dump_a_string_and_get_inner_a<'a>(t: &'a MaStruct, s: &'a str) -> &'a u32 {
        println!("{}", s);
        &t.inner_a
    }
    fn get_output(t: &MaStruct) -> &u32 {
        let s = String::from("Toto");
        let output = dump_a_string_and_get_inner_a(&t, &s);
        output
    }
    let t = MaStruct {
        inner_a: 1,
        inner_b: 2,
    };
    dbg!(get_output(&t));

    fn dump_a_string_and_get_inner_a<'a, 'b>(t: &'a T, s: &'b str) -> &'a u32 {
        println!("{}", s);
        &t.inner_a
    }
    fn get_output(t: &T) -> &u32 {
        let s = String::from("Toto");
        let output = dump_a_string_and_get_inner_a(&t, &s);
        output
    }
    let t = T {
        inner_a: 1,
        inner_b: 2,
    };
    dbg!(get_output(&t));

    fn dump_a_string_and_get_inner_a<'a: 'b, 'a>(t: &'a T, s: &'b str) -> &'a u32

    fn dump_a_string_and_get_inner_a<'a, 'b: 'a>(t: &'a T, s: &'b str) -> &'a u32

// Une simple macro nommée `say_hello_world`.
macro_rules! say_hello_world {
    // `()` indique que la macro ne prend aucun argument.
    () => (
        // La macro étendra le contenu de ce bloc.
        println!("Hello World!");
    )
}

fn main() {
    // Cet appel va étendre `println!("Hello World");`.
    say_hello_world!()
}

    Finished dev [unoptimized + debuginfo] target(s) in 0.19s
     Running `target/debug/functionnal`
Hello World!

/// Prints to the host through the serial interface, appending a newline.
#[macro_export]
macro_rules! serial_println {
    () => ($crate::serial_print!("\n"));
    ($fmt:expr, $($arg:tt)*) => ($crate::serial_print!(concat!($fmt, "\n"), $($arg)*));
    ($fmt:expr) => ($crate::serial_print!(concat!($fmt, "\n")));
}

/// Vide
/// -> Juste un simple retour a la ligne
serial_println!();

/// Une chaine de caractere avec des arguments
/// Affixher la chaine en developpant les arguments
serial_println!("{} banane(s)", 42);

/// Une chaine de caractere seule
/// Afficher la chaine de caractere
serial_println!("Toto21")

/// Implements a new C style enum with his try_from boilerplate
macro_rules! safe_convertible_enum {
    (#[$main_doc:meta]
     #[$derive:meta]
     #[repr($primitive_type:tt)]
     enum $name:ident {
         $(
             #[$doc:meta]
             $variant:ident = $value:expr,
         )*
     }) => {
        #[$main_doc]
        #[$derive]
        #[repr($primitive_type)]
        pub enum $name {
            $(
                #[$doc]
                $variant = $value,
            )*
        }

        impl core::convert::TryFrom<$primitive_type> for $name {
            type Error = Errno;
            fn try_from(n: $primitive_type) -> Result<Self, Self::Error> {
                use $name::*;
                match n {
                    $($value => Ok($variant),)*
                    _ => Err(Errno::EINVAL),
                }
            }
        }
    }
}

safe_convertible_enum!(
    /// This list contains the sockets associated function types
    #[derive(Debug, Copy, Clone)]
    #[repr(u32)]
    enum CallType {
        /// Create an endpoint for communication
        SysSocket = 1,
        /// Bind a name to a socket
        SysBind = 2,
        /// Initiate a connection on a socket. Client connection-oriented
        SysConnect = 3,
        /// Listen for connections on a socket. Server connection-oriented
        SysListen = 4,
        /// Accept a connection on a socket. Server connection-oriented
        SysAccept = 5,
        /// Send a message on a socket. Similar to write with flags. connection-oriented
        SysSend = 9,
        /// Receive a message from a socket. Similar to read with flags. connection-oriented
        SysRecv = 10,
        /// Send a message on a socket. The destination address is specified. connectionless
        SysSendTo = 11,
        /// Receive a message from a socket. The source address is specified. connectionless
        SysRecvFrom = 12,
        /// Shut down part of a full-duplex connection. connection-oriented
        SysShutdown = 13,
    }
);

cargo install bindgen

cd src
bindgen ../c_lib/lib.h > c_lib.rs

pub type size_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct custom_memory_fn {
    pub allocator:
        ::std::option::Option<unsafe extern "C" fn(arg1: size_t) -> *mut ::std::os::raw::c_void>,
    pub deallocator: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
}

extern "C" {                                                                                                                                      
    pub fn fusion_merge_tab(                                                                                                                      
        t1: *mut ::std::os::raw::c_void,                                                                                                          
        len: ::std::os::raw::c_int,                                                                                                               
        elmt: size_t,                                                                                                                             
        cmp: ::std::option::Option<                                                                                                               
            unsafe extern "C" fn(                                                                                                                 
                arg1: *mut ::std::os::raw::c_void,                                                                                                
                arg2: *mut ::std::os::raw::c_void,                                                                                                
            ) -> ::std::os::raw::c_int,                                                                                                           
        >,                                                                                                                                        
        mem: *mut custom_memory_fn,                                                                                                               
    ) -> *mut ::std::os::raw::c_void;                                                                                                             
}  

use std::env;
use std::path::Path;
use std::process::Command;

fn main() {
    let out_dir = env::var("OUT_DIR").unwrap();
    // Note that there are a number of downsides to this approach, the comments
    // below detail how to improve the portability of these commands.
    Command::new("gcc")
        .args(&["c_lib/merge_sort.c", "-c", "-fPIC", "-o"])
        .arg(&format!("{}/merge_sort.o", out_dir))
        .status()
        .unwrap();
    Command::new("ar")
        .args(&["crus", "libhello.a", "merge_sort.o"])
        .current_dir(&Path::new(&out_dir))
        .status()
        .unwrap();

    println!("cargo:rustc-link-search=native={}", out_dir);
    println!("cargo:rustc-link-lib=static=hello");
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct custom_memory_fn {
    pub allocator:
        ::std::option::Option<unsafe extern "C" fn(arg1: size_t) -> *mut ::std::os::raw::c_void>,
    pub deallocator: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
}

use std::alloc::{alloc, dealloc, Layout};

unsafe extern "C" fn allocator(arg1: c_lib::size_t) -> *mut ::std::os::raw::c_void {
    let layout = Layout::array::<u64>(arg1 as usize / std::mem::size_of::<u64>());
    let ptr = alloc(layout.unwrap());
    ptr as *mut ::std::os::raw::c_void
}

unsafe extern "C" fn deallocator(arg1: *mut ::std::os::raw::c_void) {
    let layout = Layout::new::<[u64; TAB_SIZE]>();
    dealloc(arg1 as *mut u8, layout);
}

unsafe extern "C" fn cmp(
    arg1: *mut std::os::raw::c_void,
    arg2: *mut std::os::raw::c_void,
) -> std::os::raw::c_int {
    if *(arg1 as *mut u64) < *(arg2 as *mut u64) {
        0
    } else {
        1
    }
}

const TAB_SIZE: usize = 1024 * 2;

fn main() {
    let mut custom = c_lib::custom_memory_fn {
        allocator: Some(allocator),
        deallocator: Some(deallocator),
    };

    let layout = Layout::array::<u64>(TAB_SIZE);
    let v = unsafe {
        let ptr = alloc(layout.unwrap());
        let mut v = Vec::<u64>::from_raw_parts(ptr as *mut u64, TAB_SIZE, TAB_SIZE);
        // remplit le vecteur avec des valeurs decroissantes
        for i in 0..(TAB_SIZE) {
            v[i] = ((TAB_SIZE) - i) as u64;
        }
        let old_ptr = v.as_ptr();
        let ptr = c_lib::fusion_merge_tab(
            v.as_ptr() as *mut ::std::os::raw::c_void,
            TAB_SIZE as i32,
            std::mem::size_of::<u64>() as u64,
            Some(cmp),
            &mut custom as *mut c_lib::custom_memory_fn as *mut c_lib::custom_memory_fn,
        );

        println!("Finito !");
        dbg!(old_ptr);
        dbg!(ptr);
        if old_ptr != ptr as *const u64 {
            v.leak(); // !!!
            v = Vec::<u64>::from_raw_parts(ptr as *mut u64, TAB_SIZE, TAB_SIZE);
        }
        v
    };
    for i in v.into_iter() {
        dbg!(i);
    }
}