complete chapter 7

exercises/07_threads/09_bounded/Cargo.toml

@@ -5,3 +5,4 @@ edition = "2021"
 
 [dependencies]
 ticket_fields = { path = "../../../helpers/ticket_fields" }
+thiserror="* "

exercises/07_threads/09_bounded/src/lib.rs

@@ -1,40 +1,58 @@
 // TODO: Convert the implementation to use bounded channels.
 use crate::data::{Ticket, TicketDraft};
 use crate::store::{TicketId, TicketStore};
-use std::sync::mpsc::{Receiver, Sender};
+use std::sync::mpsc::{Receiver, Sender, SyncSender};
 
 pub mod data;
 pub mod store;
 
 #[derive(Clone)]
 pub struct TicketStoreClient {
-    sender: todo!(),
+    sender: SyncSender<Command>,
 }
 
+#[derive(Debug, thiserror::Error)]
+#[error("Server is overloaded")]
+pub struct OverLoadedError;
+
 impl TicketStoreClient {
-    pub fn insert(&self, draft: TicketDraft) -> Result<TicketId, todo!()> {
-        todo!()
+    pub fn insert(&self, draft: TicketDraft) -> Result<TicketId, OverLoadedError> {
+        let (sender, receiver) = std::sync::mpsc::sync_channel(1);
+        self.sender
+            .try_send(Command::Insert {
+                draft,
+                response_channel: sender,
+            })
+            .map_err(|_| OverLoadedError);
+        Ok(receiver.recv().unwrap())
     }
 
-    pub fn get(&self, id: TicketId) -> Result<Option<Ticket>, todo!()> {
-        todo!()
+    pub fn get(&self, id: TicketId) -> Result<Option<Ticket>, OverLoadedError> {
+        let (sender, receiver) = std::sync::mpsc::sync_channel(1);
+        self.sender
+            .try_send(Command::Get {
+                id,
+                response_channel: sender,
+            })
+            .map_err(|_| OverLoadedError);
+        Ok(receiver.recv().unwrap())
     }
 }
 
 pub fn launch(capacity: usize) -> TicketStoreClient {
-    todo!();
+    let (sender, receiver) = std::sync::mpsc::sync_channel(capacity);
     std::thread::spawn(move || server(receiver));
-    todo!()
+    TicketStoreClient { sender }
 }
 
 enum Command {
     Insert {
         draft: TicketDraft,
-        response_channel: todo!(),
+        response_channel: SyncSender<TicketId>,
     },
     Get {
         id: TicketId,
-        response_channel: todo!(),
+        response_channel: SyncSender<Option<Ticket>>,
     },
 }
 
@@ -47,14 +65,14 @@ pub fn server(receiver: Receiver<Command>) {
                 response_channel,
             }) => {
                 let id = store.add_ticket(draft);
-                todo!()
+                response_channel.send(id);
             }
             Ok(Command::Get {
                 id,
                 response_channel,
             }) => {
                 let ticket = store.get(id);
-                todo!()
+                response_channel.send(ticket.cloned());
             }
             Err(_) => {
                 // There are no more senders, so we can safely break