clean up the code warnings

Author: codevalley

src/queue/q_impl.rs

@@ -11,7 +11,7 @@ impl RequestQueue for UnifiedQueue {
     /// - Ok(Some(MatchResult)) if an immediate match was found
     /// - Ok(None) if no match was found and the request was added to the queue
     /// - Err(BumpError) if there was an error adding the request
-    async fn add_request(&self, mut request: QueuedRequest) -> Result<Option<MatchResult>, BumpError> {
+    async fn add_request(&self, mut request: QueuedRequest) -> Result<Option<(MatchResult, MatchResult)>, BumpError> {
         // Ensure the request is in Active state
         request.state = RequestState::Active;
         request.reserved_by = None;
@@ -101,7 +101,7 @@ impl RequestQueue for UnifiedQueue {
                     // Note: We don't need to send to the channel here anymore
                     // as atomic_match now handles notifying both channels
 
-                    return Ok(Some(match_result));
+                    return Ok(Some((match_result.0, match_result.1)));
                 },
                 Err(e) => {
                     // Match failed - log and continue
@@ -203,7 +203,7 @@ impl RequestQueue for UnifiedQueue {
     ///
     /// DEPRECATED: This method is deprecated and should not be used with the new unified queue design.
     /// Applications should now create a channel when adding the request and wait on that channel directly.
-    async fn wait_for_match(&self, request_id: &str, ttl_ms: u64) -> Result<Option<MatchResult>, BumpError> {
+    async fn wait_for_match(&self, request_id: &str, ttl_ms: u64) -> Result<Option<(MatchResult, MatchResult)>, BumpError> {
         log::warn!("wait_for_match() is deprecated and may cause race conditions. Requests should include a channel when created.");
 
         // Create a channel for the match result

src/service.rs

@@ -113,7 +113,7 @@ impl MatchingService {
         payload: Option<String>,
         expires_at: OffsetDateTime,
         request_type: RequestType
-    ) -> (QueuedRequest, std::pin::Pin<Box<dyn std::future::Future<Output = Result<MatchResult, Box<dyn std::error::Error>>> + Send>>) {
+    ) -> (QueuedRequest, std::pin::Pin<Box<dyn std::future::Future<Output = Result<(MatchResult, MatchResult), Box<dyn std::error::Error>>> + Send>>) {
         match request_type {
             RequestType::Bump => {
                 // For Bump requests, use broadcast channel so both sides can receive
@@ -222,7 +222,7 @@ impl MatchingService {
                     sender_id: Some(request_id),
                     receiver_id: Some(our_match_result.matched_with),
                     timestamp: our_match_result.timestamp,
-                    payload: Some(request.payload),
+                    payload: None,  // Send requests don't receive payload
                     message: None,
                 });
             },
@@ -249,7 +249,7 @@ impl MatchingService {
                             sender_id: Some(request_id),
                             receiver_id: Some(our_match_result.matched_with),
                             timestamp: our_match_result.timestamp,
-                            payload: Some(request.payload),
+                            payload: None,  // Send requests don't receive payload
                             message: None,
                         });
                     },
@@ -337,12 +337,22 @@ impl MatchingService {
                         // We got a match result from the oneshot channel
                         log::info!("Match found for receive request {}", request_id);
 
+                        // Destructure the match result tuple
+                        let (send_result, recv_result) = match_result;
+                        
+                        // For receive requests, we want the receive side result
+                        let our_match_result = if request_id == send_result.matched_with {
+                            recv_result  // We're the receive side
+                        } else {
+                            send_result  // We're the send side
+                        };
+                        
                         return Ok(MatchResponse {
                             status: MatchStatus::Matched,
-                            sender_id: Some(match_result.matched_with),
+                            sender_id: Some(our_match_result.matched_with),
                             receiver_id: Some(request_id),
-                            timestamp: match_result.timestamp,
-                            payload: match_result.payload,
+                            timestamp: our_match_result.timestamp,
+                            payload: our_match_result.payload,
                             message: None,
                         });
                     },
@@ -417,17 +427,17 @@ impl MatchingService {
         // Add the request to the queue
         log::info!("Adding bump request {} to queue", request_id);
         match self.queue.add_request(queued_request).await {
-            Ok(Some(match_result)) => {
+            Ok(Some((send_result, recv_result))) => {
                 // Immediate match found
                 log::info!("Immediate match found for bump request {}", request_id);
 
                 // Choose the correct match result based on which side we are
-                let our_match_result = if request_id == send_match_result.matched_with {
+                let our_match_result = if request_id == send_result.matched_with {
                     // We are the receive side
-                    recv_match_result
+                    recv_result
                 } else {
                     // We are the send side
-                    send_match_result
+                    send_result
                 };
 
                 return Ok(MatchResponse {
@@ -446,17 +456,17 @@ impl MatchingService {
                 // Wait for a match with timeout
                 let ttl = std::time::Duration::from_millis(request.ttl as u64);
                 match tokio::time::timeout(ttl, rx).await {
-                    Ok(Ok(match_result)) => {
+                    Ok(Ok((send_result, recv_result))) => {
                         // We got a match result from the oneshot channel
                         log::info!("Match found for bump request {}", request_id);
 
                         // Choose the correct match result based on which side we are
-                        let our_match_result = if request_id == send_match_result.matched_with {
+                        let our_match_result = if request_id == send_result.matched_with {
                             // We are the receive side
-                            recv_match_result
+                            recv_result
                         } else {
                             // We are the send side
-                            send_match_result
+                            send_result
                         };
 
                         return Ok(MatchResponse {