connection_status: internal refactor to please clippy

Author: Keruspe

src/channel.rs

@@ -8,7 +8,7 @@ use crate::{
     channel_receiver_state::DeliveryCause,
     channel_status::{ChannelState, ChannelStatus},
     connection_closer::ConnectionCloser,
-    connection_status::{ConnectionState, ConnectionStep},
+    connection_status::{ConnectionResolver, ConnectionState, ConnectionStep},
     consumer::Consumer,
     consumers::Consumers,
     error_handler::ErrorHandler,
@@ -607,15 +607,15 @@ impl Channel {
 
     fn before_connection_start_ok(
         &self,
-        resolver: PromiseResolver<Connection>,
+        resolver: ConnectionResolver,
         connection: Connection,
         credentials: Credentials,
     ) {
         self.connection_status
             .set_connection_step(ConnectionStep::StartOk(resolver, connection, credentials));
     }
 
-    fn before_connection_open(&self, resolver: PromiseResolver<Connection>) {
+    fn before_connection_open(&self, resolver: ConnectionResolver) {
         self.connection_status
             .set_connection_step(ConnectionStep::Open(resolver));
     }
@@ -725,7 +725,6 @@ impl Channel {
         if let (
             ConnectionState::Connecting,
             Some(ConnectionStep::ProtocolHeader(
-                _,
                 resolver,
                 connection,
                 credentials,

src/connection_status.rs

@@ -56,7 +56,7 @@ impl ConnectionStatus {
     pub(crate) fn connection_resolver(&self) -> Option<PromiseResolver<Connection>> {
         let resolver = self.lock_inner().connection_resolver();
         // We carry the Connection here to drop the lock() above before dropping the Connection
-        resolver.map(|(_, resolver, _connection)| resolver)
+        resolver.map(|(resolver, _connection)| resolver.resolver_in)
     }
 
     pub(crate) fn connection_step_name(&self) -> Option<&'static str> {
@@ -128,17 +128,34 @@ impl ConnectionStatus {
     }
 }
 
+pub(crate) struct ConnectionResolver {
+    resolver_out: Option<PromiseResolver<()>>,
+    resolver_in: PromiseResolver<Connection>,
+}
+
+impl ConnectionResolver {
+    pub(crate) fn resolve(&self, conn: Connection) {
+        self.resolver_in.resolve(conn);
+    }
+
+    fn reject(&self, err: Error) {
+        if let Some(resolver) = self.resolver_out.as_ref() {
+            resolver.reject(err.clone());
+        }
+        self.resolver_in.reject(err);
+    }
+}
+
 pub(crate) enum ConnectionStep {
     ProtocolHeader(
-        PromiseResolver<()>,
-        PromiseResolver<Connection>,
+        ConnectionResolver,
         Connection,
         Credentials,
         SASLMechanism,
         ConnectionProperties,
     ),
-    StartOk(PromiseResolver<Connection>, Connection, Credentials),
-    Open(PromiseResolver<Connection>),
+    StartOk(ConnectionResolver, Connection, Credentials),
+    Open(ConnectionResolver),
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
@@ -201,8 +218,10 @@ impl Inner {
     ) -> Result<()> {
         self.state = ConnectionState::Connecting;
         self.connection_step = Some(ConnectionStep::ProtocolHeader(
-            resolver_out,
-            resolver_in,
+            ConnectionResolver {
+                resolver_out: Some(resolver_out),
+                resolver_in,
+            },
             conn,
             creds,
             mechanism,
@@ -218,23 +237,15 @@ impl Inner {
         self.blocked = false;
     }
 
-    fn connection_resolver(
-        &mut self,
-    ) -> Option<(
-        Option<PromiseResolver<()>>,
-        PromiseResolver<Connection>,
-        Option<Connection>,
-    )> {
+    fn connection_resolver(&mut self) -> Option<(ConnectionResolver, Option<Connection>)> {
         self.connection_step
             .take()
             .map(|connection_step| match connection_step {
-                ConnectionStep::ProtocolHeader(resolver_out, resolver_in, connection, ..) => {
-                    (Some(resolver_out), resolver_in, Some(connection))
-                }
-                ConnectionStep::StartOk(resolver, connection, ..) => {
-                    (None, resolver, Some(connection))
+                ConnectionStep::ProtocolHeader(resolver, connection, ..) => {
+                    (resolver, Some(connection))
                 }
-                ConnectionStep::Open(resolver, ..) => (None, resolver, None),
+                ConnectionStep::StartOk(resolver, connection, ..) => (resolver, Some(connection)),
+                ConnectionStep::Open(resolver, ..) => (resolver, None),
             })
     }
 
@@ -251,11 +262,8 @@ impl Inner {
     }
 
     fn poison(&mut self, err: Error) {
-        if let Some((resolver_out, resolver_in, _connection)) = self.connection_resolver() {
-            if let Some(resolver) = resolver_out {
-                resolver.reject(err.clone());
-            }
-            resolver_in.reject(err.clone());
+        if let Some((resolver, _connection)) = self.connection_resolver() {
+            resolver.reject(err.clone());
         }
         self.poison = Some(err);
     }

src/generated.rs

@@ -842,7 +842,7 @@ impl Channel {
         mechanism: &str,
         response: &str,
         locale: &str,
-        resolver: PromiseResolver<Connection>,
+        resolver: ConnectionResolver,
         connection: Connection,
         credentials: Credentials,
     ) -> Result<()> {
@@ -916,7 +916,7 @@ impl Channel {
         &self,
         virtual_host: &str,
         connection: Box<Connection>,
-        conn_resolver: PromiseResolver<Connection>,
+        conn_resolver: ConnectionResolver,
     ) -> Result<()> {
         let method = AMQPClass::Connection(protocol::connection::AMQPMethod::Open(
             protocol::connection::Open {

templates/lapin.json

@@ -8,7 +8,7 @@
         "extra_args": [
           {
             "name": "resolver",
-            "type": "PromiseResolver<Connection>"
+            "type": "ConnectionResolver"
           },
           {
             "name": "connection",
@@ -40,7 +40,7 @@
           },
           {
             "name": "conn_resolver",
-            "type": "PromiseResolver<Connection>"
+            "type": "ConnectionResolver"
           }
         ],
         "send_hook": {