Rust Structs

// Named fields
struct Host {
    name: String,
    ip: String,
    port: u16,
    active: bool,
}

// Tuple struct — fields accessed by index
struct Point(f64, f64);
let p = Point(1.0, 2.0);
println!("{}", p.0);

// Unit struct — no fields, used as marker
struct Marker;

let h = Host {
    name: String::from("sw01"),
    ip: String::from("10.50.1.10"),
    port: 22,
    active: true,
};

// Field init shorthand — variable name matches field name
let name = String::from("sw02");
let port = 443;
let h2 = Host { name, port, ..h };  // remaining fields from h
// NOTE: h.ip was moved to h2 — h.ip is no longer valid

impl Host {
    // Constructor (convention, not a language feature)
    fn new(name: &str, ip: &str, port: u16) -> Self {
        Host {
            name: name.to_string(),
            ip: ip.to_string(),
            port,
            active: true,
        }
    }

    // Method — borrows self
    fn address(&self) -> String {
        format!("{}:{}", self.ip, self.port)
    }

    // Mutable method — can modify self
    fn deactivate(&mut self) {
        self.active = false;
    }

    // Consuming method — takes ownership of self
    fn into_parts(self) -> (String, String, u16) {
        (self.name, self.ip, self.port)
    }
}

let mut h = Host::new("sw01", "10.50.1.10", 22);
println!("{}", h.address());
h.deactivate();
let (name, ip, port) = h.into_parts();
// h is consumed — no longer valid

#[derive(Debug, Clone, PartialEq)]
struct Config {
    host: String,
    port: u16,
    verbose: bool,
}

let c = Config {
    host: "localhost".into(),
    port: 8080,
    verbose: true,
};

println!("{:?}", c);       // Debug
println!("{:#?}", c);      // Pretty Debug
let c2 = c.clone();        // Clone
assert_eq!(c, c2);         // PartialEq

pub struct Connection {
    pub host: String,     // public
    pub port: u16,        // public
    token: String,        // private — only accessible in this module
}

impl Connection {
    pub fn new(host: &str, port: u16, token: &str) -> Self {
        Connection {
            host: host.into(),
            port,
            token: token.into(),
        }
    }
}
// Outside this module: Connection { host, port, .. } won't compile
// Must use Connection::new() — enforces the constructor