added: on data, lesson 01, 02, on networking 01, 02, 05

Author: robertDinca2003

docs/desktop_applications/02_Rust/10_Collections.md

@@ -143,11 +143,11 @@ Beyond the core collections, Rust's standard library offers several others for m
 
 - **`BTreeMap<K, V>`**: A map that stores key-value pairs in a sorted order, comparable to `std::map` in C++. It has a logarithmic $O(\\log n)$ time complexity for operations but guarantees a consistent, sorted iteration order.
 
-  - [Official `BTreeMap` Docs](<https://www.google.com/search?q=%5Bhttps://www.google.com/search%3Fq%3D%255Bhttps://www.google.com/search%253Fq%253D%25255Bhttps://doc.rust-lang.org/std/collections/struct.BTreeMap.html%25255D%255D%5D(https://www.google.com/search%3Fq%3D%255Bhttps://www.google.com/search%253Fq%253D%25255Bhttps://doc.rust-lang.org/std/collections/struct.BTreeMap.html%25255D%255D)(%5Bhttps://www.google.com/search%253Fq%253D%25255Bhttps://doc.rust-lang.org/std/collections/struct.BTreeMap.html%25255D%5D(https://www.google.com/search%253Fq%253D%25255Bhttps://doc.rust-lang.org/std/collections/struct.BTreeMap.html%25255D))(%255B%5Bhttps://doc.rust-lang.org/std/collections/struct.BTreeMap.html%255D%5D(https://doc.rust-lang.org/std/collections/struct.BTreeMap.html%255D)(%5Bhttps://doc.rust-lang.org/std/collections/struct.BTreeMap.html%5D(https://doc.rust-lang.org/std/collections/struct.BTreeMap.html)))>)
+  - [Official `BTreeMap` Docs](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html)
 
 - **`BTreeSet<T>`**: A collection of unique, sorted values, similar to `std::set` in C++. It also provides logarithmic $O(\\log n)$ time complexity and guarantees sorted iteration.
 
-  - [Official `BTreeSet` Docs](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html)
+  - [Official `BTreeSet` Docs](https://doc.rust-lang.org/std/collections/struct.BTreeSet.html)
 
 - **`VecDeque<T>`**: A double-ended queue, which is a growable array optimized for efficient pushes and pops from both the front and the back.
 

docs/desktop_applications/04_Data/01_File-io.md

@@ -0,0 +1,112 @@
+---
+title: File I/O in Rust
+---
+
+File Input/Output (I/O) is how your application reads and writes data to the computer's file system. In Rust, these operations are handled by the `std::fs` module and a set of I/O traits, all designed to be safe and to force you to handle potential errors.
+
+---
+
+### Opening a File
+
+The main type for file operations is `std::fs::File`. To get an instance of this type, you use `File::open`. This function returns a **`Result<File, std::io::Error>`**, not the `File` itself. This is because a file might not exist or be accessible, and Rust requires you to handle these possibilities.
+
+```rust
+use std::fs::File;
+use std::io::ErrorKind;
+
+fn main() {
+    let file_result = File::open("config.txt");
+
+    // The 'match' expression handles both possible outcomes of the Result.
+    let file = match file_result {
+        Ok(file) => file, // The file was opened successfully, we can now use it.
+        Err(error) => match error.kind() {
+            // A common, recoverable error: file not found.
+            ErrorKind::NotFound => {
+                println!("File not found. Creating a new one...");
+                File::create("config.txt").unwrap()
+            },
+            // Any other error is unrecoverable, so we panic.
+            other_error => {
+                panic!("Problem opening the file: {:?}", other_error);
+            }
+        },
+    };
+}
+```
+
+**Why it can throw errors**: Any interaction with the operating system is prone to failure. The disk could be full, the file could be deleted by another process, or you may not have the correct permissions. Rust's `Result` type prevents these failures from causing a program crash by making you explicitly write code to handle them.
+
+---
+
+### Reading and Writing
+
+Once a file is open, you can read from or write to it. The traits `std::io::Read` and `std::io::Write` provide the necessary methods.
+
+#### Reading a File
+
+To read a text file's entire contents into a `String`, you can use the `read_to_string` method. This method also returns a `Result` because the read operation can fail.
+
+```rust
+use std::fs::File;
+use std::io::{self, Read};
+
+// Returns a Result containing the file contents on success, or an error on failure.
+fn read_config(path: &str) -> Result<String, io::Error> {
+    let mut file = File::open(path)?; // The '?' operator propagates an error if the file can't be opened.
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?; // '?' propagates an error if reading fails.
+    Ok(contents)
+}
+```
+
+Here, we use the **`?` operator** which is a clean and concise way to handle `Result` types. If the `Result` is `Ok`, the value is unwrapped. If it's `Err`, the function immediately returns with that error. This keeps the code from being cluttered with `match` statements.
+
+#### Writing to a File
+
+To write to a file, you first create it with `File::create`, and then use methods like `write_all`.
+
+```rust
+use std::fs::File;
+use std::io::{self, Write};
+
+fn save_data(path: &str, data: &str) -> Result<(), io::Error> {
+    let mut file = File::create(path)?; // '?' propagates an error if the file can't be created.
+    file.write_all(data.as_bytes())?; // '?' propagates an error if writing fails.
+    Ok(())
+}
+```
+
+This function demonstrates a common pattern where `Ok(())` is returned to signal a successful operation that doesn't produce a value.
+
+---
+
+### Putting It All Together
+
+For a desktop application, you'll typically have functions that handle I/O and a top-level `main` function that manages the overall flow and displays any final errors to the user.
+
+```rust
+use std::io::{self, Write};
+use std::fs::File;
+use std::error::Error;
+
+// main() can return a Result to handle errors gracefully.
+fn main() -> Result<(), Box<dyn Error>> {
+    // Attempt to save data.
+    let save_result = save_data("log.txt", "Application started.");
+
+    // Handle the result at the top level.
+    if let Err(e) = save_result {
+        eprintln!("Error saving log file: {}", e);
+        // We can choose to continue or exit.
+    }
+
+    // This will work because the ? operator in save_data() ensures we get an error if saving fails.
+    save_data("log.txt", "Another line of text.")?;
+
+    println!("File operations successful!");
+    Ok(()) // All went well.
+}
+```
+
+In this example, the `main` function itself returns a `Result`, allowing the program to cleanly exit with an error code if any of the file operations fail. This is a robust pattern for real-world desktop applications.

docs/desktop_applications/04_Data/02_Json-and-serde.md

@@ -0,0 +1,191 @@
+---
+title: JSON and the Serde Crate
+---
+
+---
+
+JSON (JavaScript Object Notation) is a lightweight, human-readable data format used to exchange data between a server and a web application, or as a configuration file format. It is language-independent, making it the de-facto standard for APIs and many other data-sharing scenarios. A typical JSON object looks like a key-value map, with nested structures and arrays.
+
+---
+
+### Introducing Serde
+
+**Serde** is Rust's premier framework for **ser**ializing and **de**serializing data. Serialization is the process of converting a Rust data structure into a format like JSON, while deserialization is the reverse—converting JSON data into a Rust data structure. Serde is so widely used because it's fast, robust, and provides a simple way to convert complex data structures without writing boilerplate code. We'll use the `serde_json` crate, which provides the tools for handling JSON specifically.
+
+---
+
+### Setting Up Serde
+
+To use Serde in your project, you must add it and `serde_json` to your `Cargo.toml` file. The `derive` feature for `serde` is essential, as it allows Rust to automatically generate the code for serialization and deserialization for your structs and enums.
+
+```toml
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+```
+
+---
+
+### Deserialization: JSON to Rust Struct
+
+The most common use case is reading a JSON file or API response and converting it into a usable Rust data structure. You do this by defining a `struct` that mirrors the structure of your JSON data and then using the `serde_json::from_str` or `serde_json::from_reader` functions.
+
+Let's assume we have a JSON file named `user.json`:
+
+```json
+{
+  "user_id": 42,
+  "username": "alice",
+  "is_active": true,
+  "roles": ["admin", "member"]
+}
+```
+
+Now, let's create a Rust struct that corresponds to this JSON data.
+
+```rust
+use serde::Deserialize;
+use std::fs::File;
+use std::io::Read;
+
+// Use the Deserialize trait to allow Serde to parse JSON into this struct.
+#[derive(Deserialize, Debug)]
+struct User {
+    user_id: u32,
+    username: String,
+    is_active: bool,
+    roles: Vec<String>,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Open the JSON file.
+    let mut file = File::open("user.json")?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+
+    // Use serde_json::from_str to deserialize the JSON into our User struct.
+    // This function returns a Result, which we handle with the '?' operator.
+    let user: User = serde_json::from_str(&contents)?;
+
+    println!("Deserialized user: {:?}", user);
+
+    Ok(())
+}
+```
+
+The `#[derive(Deserialize, Debug)]` attribute is a procedural macro that automatically generates the code needed to convert a JSON object into a `User` struct. This is the core of Serde's power.
+
+---
+
+### Serialization: Rust Struct to JSON
+
+The reverse process, serialization, is just as easy. You create an instance of your Rust struct and use `serde_json::to_string` to convert it into a JSON string.
+
+```rust
+use serde::Serialize;
+use std::fs::File;
+use std::io::Write;
+
+// We derive Serialize to convert the struct into JSON.
+#[derive(Serialize, Debug)]
+struct Product {
+    id: u32,
+    name: String,
+    price: f64,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let product = Product {
+        id: 101,
+        name: "Laptop".to_string(),
+        price: 1200.50,
+    };
+
+    // Serialize the Product struct into a JSON string.
+    let serialized_product = serde_json::to_string(&product)?;
+
+    println!("Serialized JSON: {}", serialized_product);
+
+    // Save the serialized JSON to a file.
+    let mut file = File::create("product.json")?;
+    file.write_all(serialized_product.as_bytes())?;
+
+    println!("Product saved to product.json");
+
+    Ok(())
+}
+```
+
+The `to_string` function returns a `Result`, which is crucial for handling potential errors during serialization.
+
+---
+
+### Advanced Serde Attributes
+
+Serde provides many attributes to customize the serialization and deserialization process, which are essential for handling real-world JSON data.
+
+- `#[serde(rename = "...")]`: This attribute is used when the key in your JSON file has a different naming convention than your Rust struct field. For example, a common convention is to use snake_case in Rust and kebab-case or camelCase in JSON.
+
+  ```rust
+  #[derive(Deserialize, Debug)]
+  struct UserProfile {
+      #[serde(rename = "first-name")] // Handles "first-name" from JSON
+      first_name: String,
+      #[serde(rename = "last_name")] // Handles "last_name" from JSON
+      last_name: String,
+  }
+  ```
+
+- `#[serde(default)]`: If a field is optional in the JSON data, you can mark it with `default`. Serde will use the default value for the field's type if the key is missing from the JSON.
+
+  ```rust
+  #[derive(Deserialize, Debug)]
+  struct Settings {
+      theme: String,
+      #[serde(default)] // This field will be 'false' if not present in the JSON.
+      dark_mode: bool,
+  }
+  ```
+
+### Naming Convention Differences with Serde
+
+When the naming conventions in your JSON data don't match Rust's standard **snake_case**, you can use the **`#[serde(rename = "...")]`** attribute to map the JSON key to your Rust struct field. This is very common for handling JSON from APIs that use **camelCase** or **kebab-case**.
+
+---
+
+For example, if your JSON data uses `userName` (camelCase) and `isVerified` (camelCase), but you want to use `user_name` and `is_verified` in your Rust struct, you would do this:
+
+```rust
+use serde::{Deserialize, Serialize};
+
+// The JSON data has keys 'userName' and 'isVerified'
+// but our Rust struct uses snake_case as per Rust conventions.
+#[derive(Debug, Serialize, Deserialize)]
+struct User {
+    #[serde(rename = "userName")] // Maps 'userName' from JSON to user_name in Rust
+    user_name: String,
+
+    #[serde(rename = "isVerified")] // Maps 'isVerified' from JSON to is_verified
+    is_verified: bool,
+}
+
+fn main() {
+    let json_data = r#"
+        {
+          "userName": "rustacean_user",
+          "isVerified": true
+        }
+    "#;
+
+    let user: User = serde_json::from_str(json_data).unwrap();
+
+    println!("Deserialized User: {:?}", user);
+    // Output: Deserialized User: User { user_name: "rustacean_user", is_verified: true }
+}
+```
+
+The `#[serde(rename = "…")]` attribute tells Serde to look for the key specified in the JSON data and use its value to populate the corresponding Rust field. This allows you to maintain idiomatic Rust code while working with different external data formats.
+
+---
+
+Serde's power lies in these attributes, which allow you to effortlessly map complex JSON data to clean, idiomatic Rust code.