feat: actor refactoring default peer

src/message/peer/file_search_response.rs

@@ -1,21 +1,21 @@
 use crate::message::{Message, MessageHandler};
-use crate::peer::PeerOperation;
+use crate::peer::PeerMessage;
 use crate::types::FileSearchResult;
 use std::sync::mpsc::Sender;
 
 pub struct FileSearchResponse;
-impl MessageHandler<PeerOperation> for FileSearchResponse {
+impl MessageHandler<PeerMessage> for FileSearchResponse {
     fn get_code(&self) -> u8 {
         9
     }
-    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
         let file_search = match FileSearchResult::new_from_message(message) {
             Ok(result) => result,
             Err(_) => return, // Skip malformed search results
         };
 
         sender
-            .send(PeerOperation::FileSearchResult(file_search))
+            .send(PeerMessage::FileSearchResult(file_search))
             .unwrap();
     }
 }

src/message/peer/get_share_file_list.rs

@@ -1,17 +1,17 @@
 use crate::{
     message::{server::MessageFactory, Message, MessageHandler},
-    peer::PeerOperation,
+    peer::PeerMessage,
 };
 use std::sync::mpsc::Sender;
 
 pub struct GetShareFileList;
-impl MessageHandler<PeerOperation> for GetShareFileList {
+impl MessageHandler<PeerMessage> for GetShareFileList {
     fn get_code(&self) -> u8 {
         4
     }
-    fn handle(&self, _message: &mut Message, sender: Sender<PeerOperation>) {
+    fn handle(&self, _message: &mut Message, sender: Sender<PeerMessage>) {
         let message = MessageFactory::build_shared_folders_message(100, 800);
 
-        sender.send(PeerOperation::SendMessage(message)).unwrap();
+        sender.send(PeerMessage::SendMessage(message)).unwrap();
     }
 }

src/message/peer/peer_init.rs

@@ -2,17 +2,17 @@ use std::sync::mpsc::Sender;
 
 use crate::{
     message::{Message, MessageHandler},
-    peer::PeerOperation,
+    peer::PeerMessage,
     trace,
 };
 
 pub struct PeerInit;
-impl MessageHandler<PeerOperation> for PeerInit {
+impl MessageHandler<PeerMessage> for PeerInit {
     fn get_code(&self) -> u8 {
         1
     }
 
-    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
         message.set_pointer(4);
         let _message_code = message.read_int8();
         let username = message.read_string();
@@ -25,6 +25,6 @@ impl MessageHandler<PeerOperation> for PeerInit {
             token
         );
 
-        sender.send(PeerOperation::SetUsername(username)).unwrap();
+        sender.send(PeerMessage::SetUsername(username)).unwrap();
     }
 }

src/message/peer/place_in_queue_response.rs

@@ -1,22 +1,22 @@
 use crate::{
     message::{Message, MessageHandler},
-    peer::PeerOperation,
+    peer::PeerMessage,
 };
 use std::sync::mpsc::Sender;
 
 pub struct PlaceInQueueResponse;
 
-impl MessageHandler<PeerOperation> for PlaceInQueueResponse {
+impl MessageHandler<PeerMessage> for PlaceInQueueResponse {
     fn get_code(&self) -> u8 {
         43
     }
 
-    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
         let filename = message.read_string();
         let place = message.read_int32();
 
         sender
-            .send(PeerOperation::PlaceInQueueResponse { filename, place })
+            .send(PeerMessage::PlaceInQueueResponse { filename, place })
             .unwrap();
     }
 }

src/message/peer/transfer_request.rs

@@ -1,20 +1,20 @@
 use crate::{
     message::{Message, MessageHandler},
-    peer::PeerOperation,
+    peer::PeerMessage,
     types::Transfer,
 };
 use std::sync::mpsc::Sender;
 
 pub struct TransferRequest;
-impl MessageHandler<PeerOperation> for TransferRequest {
+impl MessageHandler<PeerMessage> for TransferRequest {
     fn get_code(&self) -> u8 {
         40
     }
-    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
         let transfer = Transfer::new_from_message(message);
 
         sender
-            .send(PeerOperation::TransferRequest(transfer))
+            .send(PeerMessage::TransferRequest(transfer))
             .unwrap();
     }
 }

src/message/peer/transfer_response.rs

@@ -1,23 +1,23 @@
 use crate::{
     message::{Message, MessageHandler},
-    peer::PeerOperation,
+    peer::PeerMessage,
 };
 use std::sync::mpsc::Sender;
 
 pub struct TransferResponse;
 
-impl MessageHandler<PeerOperation> for TransferResponse {
+impl MessageHandler<PeerMessage> for TransferResponse {
     fn get_code(&self) -> u8 {
         41
     }
 
-    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+    fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
         let token = message.read_int32();
         let allowed = message.read_int8();
         let reason = (allowed == 0).then(|| message.read_string());
 
         sender
-            .send(PeerOperation::TransferResponse {
+            .send(PeerMessage::TransferResponse {
                 token,
                 allowed: allowed == 1,
                 reason,

src/message/peer/upload_failed.rs

@@ -1,17 +1,17 @@
 use crate::info;
 use crate::{
     message::{Message, MessageHandler},
-    peer::PeerOperation,
+    peer::PeerMessage,
     types::UploadFailed,
 };
 use std::sync::mpsc::Sender;
 
 pub struct UploadFailedHandler;
-impl MessageHandler<PeerOperation> for UploadFailedHandler {
+impl MessageHandler<PeerMessage> for UploadFailedHandler {
     fn get_code(&self) -> u8 {
         46
     }
-    fn handle(&self, message: &mut Message, _sender: Sender<PeerOperation>) {
+    fn handle(&self, message: &mut Message, _sender: Sender<PeerMessage>) {
         let upload_failed = UploadFailed::new_from_message(message);
         info!("Upload failed for ${}", upload_failed.filename);
     }