fancellu

use futures::TryStreamExt;
use sqlx::postgres::{PgPoolOptions, PgRow};
use sqlx::{Error, PgPool, Row};
use uuid::Uuid;

#[derive(sqlx::FromRow, Debug)]
struct People {
    id: i32,
    name: String,
}

fancellu

use tokio::sync::broadcast;
use tokio::sync::mpsc;
use tokio::sync::oneshot;

#[tokio::main]
async fn main() {
    let (tx, rx) = oneshot::channel();

    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;

fancellu

use std::sync::Arc;
use tokio::sync::RwLock;
use tokio::time::sleep;
use tokio::time::Duration;

// Demonstrates RwLock with a shared resourced

async fn use_read_lock(id: i32, lock: Arc<RwLock<String>>) {
    let lock = lock.read().await;
    println!("reader: {}  lock string: {}", id, lock);

fancellu

use std::sync::Arc;
use tokio::sync::Barrier;
use tokio::sync::BarrierWaitResult;
use tokio::sync::Notify;
use tokio::time::sleep;
use tokio::time::Duration;

// Simulating the filling of boxes with 5 cans, from many tasks

async fn barrier_wait(barrier: Arc<Barrier>, notify: Arc<Notify>, id: usize) -> BarrierWaitResult {

fancellu

use std::sync::Arc;
use tokio::sync::Notify;
use tokio::time::sleep;
use tokio::time::Duration;

// Notify can be thought of a Semaphore with 0 permits

async fn order_packages(package_delivered: Arc<Notify>) {
    sleep(Duration::from_secs(2)).await;
    println!("Company: Find package");

fancellu

use std::sync::Arc;
use tokio::sync::{Semaphore, SemaphorePermit};
use tokio::time::sleep;
use tokio::time::Duration;

async fn person(sem: Arc<Semaphore>, name: String) {
    println!("Person {}: waiting for a permit", name);
    teller(sem, &name).await;
    println!("\tPerson {} finished", name);
}

fancellu

use std::sync::Arc;
use tokio::sync::Mutex;

// async tokio function to increment i32 behind arc mutex
async fn increment(remote: Arc<Mutex<i32>>) {
    println!("trying to lock");
    let mut tvc = remote.lock().await;
    println!("incremented");
    *tvc += 1;
}

fancellu

async fn hello(name: &str) -> String {
    // pretend to be doing some work
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    format!("Hello {}", name)
}

fn blocking() -> String {    
    println!("Blocking");

fancellu

use std::{error::Error, process};

fn cities() -> Result<(), Box<dyn Error>> {
    let mut csv_rdr = csv::Reader::from_path("data/cities.csv")?;
    for result in csv_rdr.records() {
        let record = result?;
        println!("{:?}", record);
        println!("{}",record.get(0).unwrap());
    }
    Ok(())

fancellu

use serde::Deserialize;
use std::time::Duration;

#[derive(Deserialize, Debug)]
struct Product {
    id: i32,
    title: String,
    description: String,
    price: f64,
    #[serde(rename = "discountPercentage")]