chapter-9/chapter-9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7d682cba-a6dc-49f4-8f5b-e25363ab08c8",
   "metadata": {},
   "source": [
    "# Google Colab Rust Setup\n",
    "\n",
    "The following cell is used to set up and spin up a Jupyter Notebook environment with a Rust kernel using Nix and IPC Proxy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd2296e8-b9cc-4384-aeb3-0c6485968502",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -qO- https://gist.github.com/wiseaidev/2af6bef753d48565d11bcd478728c979/archive/3f6df40db09f3517ade41997b541b81f0976c12e.tar.gz | tar xvz --strip-components=1\n",
    "!bash setup_evcxr_kernel.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60c8d72c-b011-4360-b368-d540b8d7361a",
   "metadata": {},
   "source": [
    "## Working with Devices I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38339871-7f3d-49d8-9b4f-e77f9e2a88da",
   "metadata": {},
   "source": [
    "### Opening a File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "77c46244-70d5-4ddc-811f-d9872521ca03",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::fs::File;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let file = File::open(\"example.txt\")?;\n",
    "    // Now, 'file' is a handle to the opened file.\n",
    "    Ok(())\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2982f855-0b6d-41a6-9360-accaf279f8b0",
   "metadata": {},
   "source": [
    "#### Reading from a File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "887facc7-184e-4e50-a68c-c10687996d83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::Read;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let mut file = File::open(\"example.txt\")?;\n",
    "    let mut contents = String::new();\n",
    "    file.read_to_string(&mut contents)?;\n",
    "    // 'contents' now holds the content of the file.\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed033184-ecc8-45c9-a54d-048abd5c2307",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::{BufRead, BufReader};\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let file = File::open(\"example.txt\")?;\n",
    "    let reader = BufReader::new(file);\n",
    "\n",
    "    for line in reader.lines() {\n",
    "        let line = line?;\n",
    "        // Process each line as needed.\n",
    "    }\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d089d83c-807a-4715-b5d9-e50cf68be2f4",
   "metadata": {},
   "source": [
    "#### Writing to a File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3de75cf3-3bce-467f-b6d5-c4cc8650f744",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::Write;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let mut file = File::create(\"new_file.txt\")?;\n",
    "    file.write_all(b\"Hello, Rust!\")?;\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d3e96285-c0cd-4d2c-97e7-60e476f52d9b",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep serde = {version = \"1.0.193\", features = [\"derive\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e4348921-2fbf-447b-a9d1-8490d0359880",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep serde_json = {version = \"1.0.108\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "77c7926c-4f6f-43f9-b773-28dc17c5e6fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use serde::{Serialize, Deserialize};\n",
    "use std::fs::File;\n",
    "use serde_json::to_writer;\n",
    "\n",
    "\n",
    "#[derive(Serialize, Deserialize)]\n",
    "struct Configuration {\n",
    "    name: String,\n",
    "    value: i32,\n",
    "}\n",
    "\n",
    "fn main() -> Result<(), Box<dyn std::error::Error>> {\n",
    "    let config = Configuration {\n",
    "        name: String::from(\"setting\"),\n",
    "        value: 42,\n",
    "    };\n",
    "\n",
    "    let file = File::create(\"config.json\")?;\n",
    "    to_writer(file, &config)?;\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cee9692e-8244-4de3-8f2b-a698a0f0ffdd",
   "metadata": {},
   "source": [
    "#### Closing a File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d5ced5d8-31da-4c1f-8c2c-59898b0ac78e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::Write;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let mut file = File::create(\"new_file.txt\")?;\n",
    "    file.write_all(b\"Hello, Rust!\")?;\n",
    "    // The 'file' variable goes out of scope here, and the file is automatically closed.\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfe31fb2-43b9-4099-a53e-258459516b36",
   "metadata": {},
   "source": [
    "#### Creating Directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f90805ab-1aa0-45a9-b88f-878005d346a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    fs::create_dir(\"new_directory\")?;\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1430f0c-e4fc-4da2-88b2-2af3c12a0ca0",
   "metadata": {},
   "source": [
    "#### Renaming and Moving Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a08070a2-524a-4133-8a19-2600a61a69d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    fs::rename(\"old_file.txt\", \"new_file.txt\")?;\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45b0f5fc-9083-4570-aa11-f6a20d35f03c",
   "metadata": {},
   "source": [
    "#### Checking File Metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "484837bb-9fa3-4b12-9301-9334d2ee651e",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep chrono = {version = \"0.4.31\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d6fed0c8-16f3-4591-a4fd-cee5da2f19f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File size: 0 bytes\n",
      "Last modified: 2023-11-01 19:24:56\n",
      "Permissions: 755\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use chrono::NaiveDateTime;\n",
    "use std::fs::metadata;\n",
    "use std::io;\n",
    "use std::os::unix::fs::PermissionsExt;\n",
    "use std::time::SystemTime;\n",
    "\n",
    "fn main() -> io::Result<()> {\n",
    "    let metadata = metadata(\"example.txt\")?;\n",
    "    println!(\"File size: {} bytes\", metadata.len());\n",
    "\n",
    "    if let Ok(modified_time) = metadata.modified() {\n",
    "        let modified_time = modified_time\n",
    "            .duration_since(SystemTime::UNIX_EPOCH)\n",
    "            .unwrap_or_default();\n",
    "\n",
    "        let modified_datetime =\n",
    "            NaiveDateTime::from_timestamp_opt(modified_time.as_secs() as i64, 0).unwrap();\n",
    "\n",
    "        println!(\"Last modified: {}\", modified_datetime);\n",
    "    } else {\n",
    "        eprintln!(\"Unable to retrieve modified time\");\n",
    "    }\n",
    "    let permissions = metadata.permissions().mode();\n",
    "    println!(\"Permissions: {:o}\", permissions & 0o777);\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1076c94d-372d-48e5-ad61-2cde2587f1ee",
   "metadata": {},
   "source": [
    "#### Deleting Files and Directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "21af2e95-fe3e-4c88-989d-4ba92ac5b22e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Err(Os { code: 2, kind: NotFound, message: \"No such file or directory\" })"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    fs::remove_file(\"file_to_delete.txt\")?;\n",
    "    fs::remove_dir(\"directory_to_delete\")?;\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62e3b1f1-179b-45e1-b370-c6dfd914f1e5",
   "metadata": {},
   "source": [
    "#### Traversing Directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9ded0691-7676-4c4e-b5b8-72520de14d7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entry name: \"config.json\"\n",
      "Entry type: File\n",
      "Entry name: \"new_file.txt\"\n",
      "Entry type: File\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs;\n",
    "use std::os::unix::fs::FileTypeExt;\n",
    "use std::path::Path;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let dir = fs::read_dir(\"path_to_directory\")?;\n",
    "\n",
    "    for entry in dir {\n",
    "        let entry = entry?;\n",
    "        let path = entry.path();\n",
    "        println!(\"Entry name: {:?}\", path.file_name().unwrap_or_default());\n",
    "\n",
    "        let file_type = entry.file_type()?;\n",
    "        let file_type_str = if file_type.is_file() {\n",
    "            \"File\"\n",
    "        } else if file_type.is_dir() {\n",
    "            \"Directory\"\n",
    "        } else if file_type.is_symlink() {\n",
    "            \"Symbolic Link\"\n",
    "        } else if file_type.is_char_device() {\n",
    "            \"Character Device\"\n",
    "        } else if file_type.is_block_device() {\n",
    "            \"Block Device\"\n",
    "        } else if file_type.is_fifo() {\n",
    "            \"FIFO (Named Pipe)\"\n",
    "        } else if file_type.is_socket() {\n",
    "            \"Socket\"\n",
    "        } else {\n",
    "            \"Unknown\"\n",
    "        };\n",
    "\n",
    "        println!(\"Entry type: {}\", file_type_str);\n",
    "    }\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "523c632c-e041-4a81-b105-2b924b7c4b62",
   "metadata": {},
   "source": [
    "#### Working with File Paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6a938a11-c989-4556-ace8-a13a6cbcdb42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New path: \"/usr/local/bin\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::path::PathBuf;\n",
    "\n",
    "fn main() {\n",
    "    let base_path = PathBuf::from(\"/usr/local\");\n",
    "    let new_path = base_path.join(\"bin\");\n",
    "\n",
    "    println!(\"New path: {:?}\", new_path);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "504caa38-550a-4141-a0fa-d5ecd8bf091d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent directory: \"/usr/local\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::path::Path;\n",
    "\n",
    "fn main() {\n",
    "    let path = Path::new(\"/usr/local/bin\");\n",
    "    if let Some(parent) = path.parent() {\n",
    "        println!(\"Parent directory: {:?}\", parent);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5be09b5d-2139-4b83-83dc-afab2d1b0fad",
   "metadata": {},
   "source": [
    "#### Reading and Writing Binary Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "16aadaab-6894-4571-83d0-d52cc0dfc230",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::Read;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let mut file = File::open(\"binary_file.bin\")?;\n",
    "    let mut buffer = Vec::new();\n",
    "\n",
    "    file.read_to_end(&mut buffer)?;\n",
    "\n",
    "    // 'buffer' now contains the binary data from the file.\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6ccc9060-91f2-46f3-9038-b158125fcbd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::Write;\n",
    "\n",
    "fn main() -> Result<(), std::io::Error> {\n",
    "    let mut file = File::create(\"binary_output.bin\")?;\n",
    "    let data = vec![0x48, 0x65, 0x6C, 0x6C, 0x6F];\n",
    "    file.write_all(&data)?;\n",
    "\n",
    "    // The binary data has been successfully written to the file.\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ee276a9-c379-429a-a74d-4d836c693fc5",
   "metadata": {},
   "source": [
    "#### Error Handling and Result Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f1d581b0-8e46-4140-b6e7-474e7cb0cb73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File operations completed successfully.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::{Read, Write};\n",
    "\n",
    "fn read_and_write_files() -> Result<(), std::io::Error> {\n",
    "    let mut read_file = File::open(\"input.txt\")?;\n",
    "\n",
    "    let mut write_file = File::create(\"output.txt\")?;\n",
    "\n",
    "    let mut buffer = Vec::new();\n",
    "\n",
    "    read_file.read_to_end(&mut buffer)?;\n",
    "\n",
    "    write_file.write_all(&buffer)?;\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    match read_and_write_files() {\n",
    "        Ok(_) => println!(\"File operations completed successfully.\"),\n",
    "        Err(e) => eprintln!(\"Error: {}\", e),\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6d634df-a9b7-4bca-a8dd-9c3f84750aa8",
   "metadata": {},
   "source": [
    "#### Overview of Working with Hardware Devices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2997ca92-5d08-415f-ae8b-cc381db31123",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep rppal = {version = \"0.15.0\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "191ebe26-3498-4c8b-b596-6bc48a1c6881",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Err(UnknownModel)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use rppal::gpio::Gpio;\n",
    "use std::error::Error;\n",
    "\n",
    "fn main() -> Result<(), Box<dyn Error>> {\n",
    "    let gpio = Gpio::new()?;\n",
    "    let pin = gpio.get(17)?;\n",
    "\n",
    "    let mut pin = pin.into_output();\n",
    "\n",
    "    // Handle any errors that may occur during pin operations\n",
    "    if pin.set_high() != () {\n",
    "        eprintln!(\"Error setting pin high\");\n",
    "    }\n",
    "\n",
    "    // Do some work here, interacting with the GPIO pin\n",
    "\n",
    "    if pin.set_low() != () {\n",
    "        eprintln!(\"Error setting pin low\");\n",
    "    }\n",
    "\n",
    "    // The pin is automatically released when it goes out of scope\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9d951b78-a40a-40d1-b5a3-0d8024f4b317",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep i2cdev = {version = \"0.6.0\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b36b10bc-36ab-42b9-b123-bf4f9c790d28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Err(Io(Os { code: 13, kind: PermissionDenied, message: \"Permission denied\" }))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use i2cdev::linux::LinuxI2CDevice;\n",
    "use i2cdev::core::I2CDevice;\n",
    "use std::error::Error;\n",
    "\n",
    "fn main() -> Result<(), Box<dyn Error>> {\n",
    "    let mut bus = LinuxI2CDevice::new(\"/dev/i2c-1\", 0x68)?;\n",
    "\n",
    "    let mut buffer: [u8; 2] = [0; 2];\n",
    "    bus.write(&[0x1])?; // Command to read from the sensor\n",
    "    bus.read(&mut buffer)?;\n",
    "\n",
    "    let sensor_value = (u16::from(buffer[0]) << 8) | u16::from(buffer[1]);\n",
    "    println!(\"Sensor value: {}\", sensor_value);\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7534ef46-fba4-4265-8e9f-94bd8917d7e6",
   "metadata": {},
   "source": [
    "### Advanced File Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7349cacb-9a0b-4010-aaa7-a02d302464cc",
   "metadata": {},
   "source": [
    "#### Symbolic Links and Hard Links"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b304a22a-998a-4e14-9168-38f212f47ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::os::unix::fs;\n",
    "\n",
    "fs::symlink(\"target_file.txt\", \"symlink_to_target.txt\")?;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "003b7e29-353c-4cb5-b50e-45ea078dc0f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::fs;\n",
    "\n",
    "fs::hard_link(\"source_file.txt\", \"hard_link_to_source.txt\")?;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e4eff3c-b0c2-4e03-b794-437279b93464",
   "metadata": {},
   "source": [
    "#### Locking Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9f6f4b69-419f-4b2c-9fdf-7827cb92f8ef",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep fs2 = {version = \"0.4.3\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "beddc5b7-8d38-48dd-8a0d-39c8c7c173f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acquired exclusive lock.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use fs2::FileExt;\n",
    "use std::fs::File;\n",
    "use std::io;\n",
    "\n",
    "fn main() -> Result<(), io::Error> {\n",
    "    let file = File::create(\"locked_file.txt\")?;\n",
    "\n",
    "    // Attempt to acquire an exclusive lock on the file.\n",
    "    if let Ok(mut _lock) = file.try_lock_exclusive() {\n",
    "        println!(\"Acquired exclusive lock.\");\n",
    "        // Perform exclusive operations.\n",
    "\n",
    "        // Lock is automatically released when 'lock' goes out of scope.\n",
    "    } else {\n",
    "        println!(\"Failed to acquire exclusive lock.\");\n",
    "    }\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7427c465-2f68-4b9b-9218-cd3aca2d274a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read 22 bytes: \n",
      "line 0\n",
      "line 1\n",
      "line 2\n",
      "\n",
      "Thread ThreadId(2) acquired shared lock for read-only access.\n",
      "Thread ThreadId(2) is processing the shared content: \n",
      "line 0\n",
      "line 1\n",
      "line 2\n",
      "\n",
      "Thread ThreadId(1) acquired shared lock for read-only access.\n",
      "Thread ThreadId(1) is processing the shared content: \n",
      "line 0\n",
      "line 1\n",
      "line 2\n",
      "\n",
      "Thread ThreadId(4) acquired shared lock for read-only access.\n",
      "Thread ThreadId(4) is processing the shared content: \n",
      "line 0\n",
      "line 1\n",
      "line 2\n",
      "\n",
      "Thread ThreadId(5) acquired shared lock for read-only access.\n",
      "Thread ThreadId(5) is processing the shared content: \n",
      "line 0\n",
      "line 1\n",
      "line 2\n",
      "\n",
      "Thread ThreadId(3) acquired shared lock for read-only access.\n",
      "Thread ThreadId(3) is processing the shared content: \n",
      "line 0\n",
      "line 1\n",
      "line 2\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use fs2::FileExt;\n",
    "use std::fs::{self, File};\n",
    "use std::io;\n",
    "use std::io::prelude::*;\n",
    "use std::sync::Arc;\n",
    "use std::thread;\n",
    "\n",
    "fn main() -> Result<(), io::Error> {\n",
    "    // Create or overwrite the file with some content.\n",
    "    let content = \"\\nline 0\\nline 1\\nline 2\\n\";\n",
    "    fs::write(\"shared_file.txt\", content)?;\n",
    "\n",
    "    // Read the file content outside the locked section.\n",
    "    let file = File::open(\"shared_file.txt\")?;\n",
    "    let mut buffer = String::new();\n",
    "    if let Ok(reader) = io::BufReader::new(file.try_clone()?).read_to_string(&mut buffer) {\n",
    "        println!(\"Read {} bytes: {}\", reader, &buffer);\n",
    "    } else {\n",
    "        println!(\"Failed to read the file.\");\n",
    "    }\n",
    "\n",
    "    // Wrap the buffer in an Arc to share ownership.\n",
    "    let buffer = Arc::new(buffer);\n",
    "\n",
    "    // Spawn multiple threads to access the shared content.\n",
    "    let num_threads = 5;\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for _ in 0..num_threads {\n",
    "        let file_clone = file.try_clone();\n",
    "        let buffer_clone = Arc::clone(&buffer); // Use Arc to share ownership\n",
    "\n",
    "        let handle = thread::spawn(move || {\n",
    "            if let Ok(mut _lock) = file_clone.unwrap().try_lock_shared() {\n",
    "                println!(\n",
    "                    \"Thread {:?} acquired shared lock for read-only access.\",\n",
    "                    thread::current().id()\n",
    "                );\n",
    "\n",
    "                // Perform read-only operations on the shared content.\n",
    "                println!(\n",
    "                    \"Thread {:?} is processing the shared content: {}\",\n",
    "                    thread::current().id(),\n",
    "                    &buffer_clone // Use the shared Arc\n",
    "                );\n",
    "            } else {\n",
    "                println!(\n",
    "                    \"Thread {:?} failed to acquire shared lock.\",\n",
    "                    thread::current().id()\n",
    "                );\n",
    "            }\n",
    "        });\n",
    "\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ce499cb-ca3b-471a-9731-814f8eb2e7c0",
   "metadata": {},
   "source": [
    "#### Memory-Mapped Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "cf49e0e6-445f-4439-9fee-6ab1830a080c",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep memmap = {version = \"0.7.0\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "cee94bdb-58eb-45d4-a449-349045cd3b13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io;\n",
    "use std::io::prelude::*;\n",
    "use memmap::Mmap;\n",
    "\n",
    "fn main() -> Result<(), io::Error> {\n",
    "    let file = File::open(\"large_file.bin\")?;\n",
    "    let mmap = unsafe { Mmap::map(&file)? };\n",
    "\n",
    "    // Access the memory-mapped data as a slice.\n",
    "    let data = &mmap;\n",
    "\n",
    "    // Perform read operations on 'data'.\n",
    "    let max_bytes_to_print = 100;\n",
    "    for i in 0..max_bytes_to_print {\n",
    "        // Convert the byte to an ASCII code character and print it.\n",
    "        print!(\"{} \", data[i] as char);\n",
    "    }\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d873c49-7a9e-4cf6-aad7-a6e575bafc77",
   "metadata": {},
   "source": [
    "### Network Programming and Device I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64b915fd-605d-458c-acd8-1078b5547f28",
   "metadata": {},
   "source": [
    "#### Sockets and Protocols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a4962b5b-4723-4ec1-8dcb-75e40d418fb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sensor server listening on 0.0.0.0:8080\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Subprocess terminated with status: signal: 9 (SIGKILL)",
     "output_type": "error",
     "traceback": [
      "Subprocess terminated with status: signal: 9 (SIGKILL)"
     ]
    }
   ],
   "source": [
    "use std::net::TcpListener;\n",
    "use std::io::{Read, Write};\n",
    "\n",
    "fn main() -> Result<(), Box<dyn std::error::Error>> {\n",
    "    let listener = TcpListener::bind(\"0.0.0.0:8080\")?;\n",
    "    println!(\"Sensor server listening on 0.0.0.0:8080\");\n",
    "\n",
    "    for stream in listener.incoming() {\n",
    "        let mut stream = stream?;\n",
    "        let mut buffer = [0; 1024];\n",
    "        stream.read(&mut buffer)?;\n",
    "\n",
    "        // Process sensor data from the remote device\n",
    "        let sensor_data = process_sensor_data(&buffer);\n",
    "\n",
    "        // Perform device I/O operations with the sensor data\n",
    "        perform_device_io(&sensor_data);\n",
    "\n",
    "        // Respond to the remote device\n",
    "        stream.write_all(b\"Data received and processed.\")?;\n",
    "    }\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "fn process_sensor_data(data: &[u8]) -> SensorData {\n",
    "    // Process the received data and convert it into a structured format\n",
    "    // In a real-world scenario, this could involve deserialization and validation\n",
    "    // For simplicity, we assume direct conversion in this example\n",
    "    SensorData::from_bytes(data)\n",
    "}\n",
    "\n",
    "fn perform_device_io(sensor_data: &SensorData) {\n",
    "    // Perform device I/O operations using the sensor data\n",
    "    // This could involve controlling actuators, making decisions, or storing data\n",
    "    // In this example, we perform a hypothetical device I/O operation\n",
    "    // by printing the sensor data\n",
    "    println!(\"Received sensor data: {:?}\", sensor_data);\n",
    "}\n",
    "\n",
    "#[derive(Debug)]\n",
    "struct SensorData {\n",
    "    // Define the structure for sensor data\n",
    "}\n",
    "\n",
    "impl SensorData {\n",
    "    fn from_bytes(_data: &[u8]) -> SensorData {\n",
    "        // Convert the received bytes into a SensorData instance\n",
    "        // In a real-world application, this might involve deserialization\n",
    "        // and validation of the data.\n",
    "        // In this simplified example, we assume the bytes directly represent\n",
    "        // the sensor data.\n",
    "        SensorData {}\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "795c971b-8ff4-4a6f-9895-5ee369b63ea9",
   "metadata": {},
   "source": [
    "#### Asynchronous Networking and Device I/O"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2fbe3014-b505-4c8e-86e5-60cb862d0fc7",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep tokio = { version = \"1.35.0\", features = [\"full\"] }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "99b80131-7b08-4edd-85e2-9580ff8651ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sensor server listening on 0.0.0.0:8080\n",
      "new client: 127.0.0.1:37118\n",
      "new client: 127.0.0.1:37114\n",
      "new client: 127.0.0.1:37116\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:37144\n",
      "new client: 127.0.0.1:37142\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:43962\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:43970\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:43972\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:43982\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:43996\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:39376\n",
      "new client: 127.0.0.1:39386\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:39390\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:39392\n",
      "new client: 127.0.0.1:39404\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:38146\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:38160\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:38174\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:38186\n",
      "Received sensor data: SensorData\n",
      "new client: 127.0.0.1:38202\n",
      "Received sensor data: SensorData\n"
     ]
    },
    {
     "ename": "Error",
     "evalue": "Subprocess terminated with status: signal: 9 (SIGKILL)",
     "output_type": "error",
     "traceback": [
      "Subprocess terminated with status: signal: 9 (SIGKILL)"
     ]
    }
   ],
   "source": [
    "use tokio::net::TcpListener;\n",
    "use tokio::io::{AsyncWriteExt, AsyncReadExt};\n",
    "use std::error::Error;\n",
    "use std::net::SocketAddr;\n",
    "\n",
    "#[tokio::main]\n",
    "async fn main() -> Result<(), Box<dyn Error>> {\n",
    "    let addr: SocketAddr = \"0.0.0.0:8080\".parse()?;\n",
    "    let listener = TcpListener::bind(&addr).await?;\n",
    "    println!(\"Sensor server listening on 0.0.0.0:8080\");\n",
    "\n",
    "    loop {\n",
    "        let (mut socket, addr) = listener.accept().await?;\n",
    "        println!(\"new client: {:?}\", addr);\n",
    "        tokio::spawn(async move {\n",
    "            let mut buf = vec![0; 1024];\n",
    "            if let Err(e) = socket.read(&mut buf).await {\n",
    "                eprintln!(\"Error reading from socket: {}\", e);\n",
    "                return;\n",
    "            }\n",
    "\n",
    "            // Process sensor data from the remote device\n",
    "            let sensor_data = process_sensor_data(&buf);\n",
    "\n",
    "            // Perform device I/O operations with the sensor data\n",
    "            perform_device_io(&sensor_data);\n",
    "\n",
    "            // Respond to the remote device with a custom response\n",
    "            let response = b\"Data received and processed\\n\";\n",
    "            if let Err(e) = socket.write_all(response).await {\n",
    "                eprintln!(\"Error writing to socket: {}\", e);\n",
    "                return;\n",
    "            }\n",
    "            // Flush the output buffer to ensure the response is sent immediately\n",
    "            if let Err(e) = socket.flush().await {\n",
    "                eprintln!(\"Error flushing socket: {}\", e);\n",
    "            }\n",
    "        });\n",
    "    }\n",
    "}\n",
    "\n",
    "fn process_sensor_data(data: &[u8]) -> SensorData {\n",
    "    // Process the received data and convert it into a structured format\n",
    "    // In a real-world scenario, this could involve deserialization and validation\n",
    "    // For simplicity, we assume direct conversion in this example\n",
    "    SensorData::from_bytes(data)\n",
    "}\n",
    "\n",
    "fn perform_device_io(sensor_data: &SensorData) {\n",
    "    // Perform device I/O operations using the sensor data\n",
    "    // This could involve controlling actuators, making decisions, or storing data\n",
    "    // In this example, we perform a hypothetical device I/O operation\n",
    "    // by printing the sensor data\n",
    "    println!(\"Received sensor data: {:?}\", sensor_data);\n",
    "}\n",
    "\n",
    "#[derive(Debug)]\n",
    "struct SensorData {\n",
    "    // Define the structure for sensor data\n",
    "}\n",
    "\n",
    "impl SensorData {\n",
    "    fn from_bytes(_data: &[u8]) -> SensorData {\n",
    "        // Convert the received bytes into a SensorData instance\n",
    "        // In a real-world application, this might involve deserialization\n",
    "        // and validation of the data.\n",
    "        // In this simplified example, we assume the bytes directly represent\n",
    "        // the sensor data.\n",
    "        SensorData {}\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c3e4701e-f2d4-4c1c-82d6-e96f336240b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::process::{Command, Output, Stdio};\n",
    "\n",
    "// A helper function to execute a shell command from a Rust script\n",
    "fn execute_command(command: &str) -> Result<(), std::io::Error> {\n",
    "    let status = Command::new(\"bash\")\n",
    "        .arg(\"-c\")\n",
    "        .arg(command)\n",
    "        .stderr(Stdio::inherit())\n",
    "        .status()?;\n",
    "\n",
    "    if status.success() {\n",
    "        Ok(())\n",
    "    } else {\n",
    "        Err(std::io::Error::from_raw_os_error(status.code().unwrap_or(1)))\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ef5eed2-8236-4530-a1b1-1cf09c2d1234",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.03s\n",
      "     Running `target/debug/asynchronous-networking`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sensor server listening on 0.0.0.0:8080\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n",
      "Received sensor data: SensorData\n"
     ]
    }
   ],
   "source": [
    "let command = \"cd asynchronous-networking && cargo run\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cee0b2d9-f1b5-4ce2-92ce-e67260125f67",
   "metadata": {},
   "source": [
    "#### Networking Libraries and Device I/O\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "be2739f3-b0c8-4bb3-a0d1-d235d3c76d13",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep tokio = {version = \"1.35.0\", featrues=[\"full\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6ca98651-de07-485d-9ecf-e0ae9ea9fe2e",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep hyper = {version = \"0.14.27\", features = [\"http1\", \"server\", \"tcp\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4bace660-a622-4c36-9b67-827e03539b43",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "failed to resolve: could not find `main` in `tokio`",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[E0433] Error:\u001b[0m failed to resolve: could not find `main` in `tokio`",
      "    \u001b[38;5;246m╭\u001b[0m\u001b[38;5;246m─\u001b[0m\u001b[38;5;246m[\u001b[0mcommand_11:1:1\u001b[38;5;246m]\u001b[0m",
      "    \u001b[38;5;246m│\u001b[0m",
      " \u001b[38;5;246m13 │\u001b[0m \u001b[38;5;249m#\u001b[0m\u001b[38;5;249m[\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249mk\u001b[0m\u001b[38;5;249mi\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;54mm\u001b[0m\u001b[38;5;54ma\u001b[0m\u001b[38;5;54mi\u001b[0m\u001b[38;5;54mn\u001b[0m\u001b[38;5;249m]\u001b[0m",
      " \u001b[38;5;240m   │\u001b[0m          \u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m┬\u001b[0m\u001b[38;5;54m─\u001b[0m  ",
      " \u001b[38;5;240m   │\u001b[0m            \u001b[38;5;54m╰\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m could not find `main` in `tokio`",
      "\u001b[38;5;246m────╯\u001b[0m"
     ]
    },
    {
     "ename": "Error",
     "evalue": "`impl Future<Output = Result<(), Box<(dyn std::error::Error + 'static)>>>` doesn't implement `Debug`",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[E0277] Error:\u001b[0m `impl Future<Output = Result<(), Box<(dyn std::error::Error + 'static)>>>` doesn't implement `Debug`"
     ]
    }
   ],
   "source": [
    "use hyper::service::{make_service_fn, service_fn};\n",
    "use hyper::{Body, Request, Response, Server};\n",
    "use std::convert::Infallible;\n",
    "use std::net::SocketAddr;\n",
    "\n",
    "async fn device_control(_req: Request<Body>) -> Result<Response<Body>, Infallible> {\n",
    "    // Implement device control logic here\n",
    "    // This function could process incoming requests to control devices\n",
    "\n",
    "    Ok(Response::new(Body::from(\"Device control response\")))\n",
    "}\n",
    "\n",
    "#[tokio::main]\n",
    "async fn main() -> Result<(), Box<dyn std::error::Error>> {\n",
    "    let make_svc = make_service_fn(|_conn| {\n",
    "        let svc = service_fn(device_control);\n",
    "        async move { Ok::<_, Infallible>(svc) }\n",
    "    });\n",
    "\n",
    "    let addr: SocketAddr = ([127, 0, 0, 1], 8080).into();\n",
    "    let server = Server::bind(&addr).serve(make_svc);\n",
    "\n",
    "    println!(\"Device control server listening on http://127.0.0.1:8080\");\n",
    "\n",
    "    server.await?;\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()\n",
    "// TODO: Report an evcxr bug?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "517e5d04-23cd-40ce-b06f-1f5af4ab1368",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "   Compiling networking-libraries v0.1.0 (/home/mahmoud/Desktop/Rust Book/rust-lang-book/chapter-9/networking-libraries)\n",
      "    Finished dev [unoptimized + debuginfo] target(s) in 2.29s\n",
      "     Running `target/debug/networking-libraries`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device control server listening on http://127.0.0.1:8080\n"
     ]
    }
   ],
   "source": [
    "let command = \"cd networking-libraries && cargo run\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7bf5bd7-e9ab-46ce-8399-0c24d9b5689e",
   "metadata": {},
   "source": [
    "### Parallelism, Concurrency, and Device I/O"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e0eb6f1e-fc82-420a-8363-1f779e059f77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading sensor data...\n",
      "Sensor thread finished reading data.\n",
      "Controlling the device...\n",
      "Device thread finished controlling the device.\n",
      "Main thread finished.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::sync::{Arc, Mutex};\n",
    "\n",
    "fn main() {\n",
    "    let sensor_data = Arc::new(Mutex::new(SensorData {}));\n",
    "    let device = Arc::new(Mutex::new(Device::new()));\n",
    "\n",
    "    let sensor_thread = thread::spawn({\n",
    "        let sensor_data = Arc::clone(&sensor_data);\n",
    "        move || {\n",
    "            // Read sensor data and update shared data\n",
    "            let mut sensor_data = sensor_data.lock().unwrap();\n",
    "            sensor_data.read();\n",
    "            println!(\"Sensor thread finished reading data.\");\n",
    "        }\n",
    "    });\n",
    "\n",
    "    let device_thread = thread::spawn({\n",
    "        let sensor_data_clone = Arc::clone(&sensor_data);\n",
    "        let device_clone = Arc::clone(&device);\n",
    "        move || {\n",
    "            // Control the device based on sensor data\n",
    "            let sensor_data = sensor_data_clone.lock().unwrap();\n",
    "            let mut device = device_clone.lock().unwrap();\n",
    "            device.control(&sensor_data);\n",
    "            println!(\"Device thread finished controlling the device.\");\n",
    "        }\n",
    "    });\n",
    "\n",
    "    sensor_thread.join().unwrap();\n",
    "    device_thread.join().unwrap();\n",
    "    println!(\"Main thread finished.\");\n",
    "}\n",
    "\n",
    "struct SensorData {\n",
    "    // Define the structure for sensor data\n",
    "}\n",
    "\n",
    "impl SensorData {\n",
    "    fn read(&mut self) {\n",
    "        // Simulate reading sensor data\n",
    "        println!(\"Reading sensor data...\");\n",
    "    }\n",
    "}\n",
    "\n",
    "struct Device {\n",
    "    // Define the structure for the device\n",
    "}\n",
    "\n",
    "impl Device {\n",
    "    fn new() -> Device {\n",
    "        // Initialize the device\n",
    "        Device {}\n",
    "    }\n",
    "\n",
    "    fn control(&mut self, _sensor_data: &SensorData) {\n",
    "        // Control the device based on sensor data\n",
    "        println!(\"Controlling the device...\");\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7a57931-b75d-4270-825a-9661dcce293b",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}