[git-transport] put request writer into general spot…

…even though only a little bit can be shread soon once ExtendedBufRead is available in async. Clearly a mistake to try this one first :D

Sebastian Thiel committed 5 years ago

Commit af07ebf1 parent 5f98ac13 files · +41 −29Browse files

Unified · Split

3 files

git-transport/src/client/blocking_io/mod.rs +17 −15
git-transport/src/client/mod.rs +14 −8
git-transport/src/client/request.rs +10 −6

git-transport/src/client/blocking_io/mod.rs+17−15

+use std::io;
+pub use bufread_ext::{ExtendedBufRead, HandleProgress};
+pub use trait_ext::TransportV2Ext;
+pub use crate::client::RequestWriter;
+use crate::{
+    client::{capabilities, Capabilities, Error, Identity, MessageKind, WriteMode},
+    Protocol, Service,
+};
 ///
 pub mod connect;
 #[cfg(feature = "http-client-curl")]
 pub mod http;
-pub mod request;
-pub use request::RequestWriter;
 mod bufread_ext;
-pub use bufread_ext::{ExtendedBufRead, HandleProgress};
 ///
 pub mod ssh;
-use crate::{
-    client::{capabilities, Capabilities, Error, Identity, MessageKind, WriteMode},
-    Protocol, Service,
-};
-use std::io;
 /// The response of the [`handshake()`][Transport::handshake()] method.
 pub struct SetServiceResponse<'a> {
     /// The protocol the service can provide. May be different from the requested one
 }
 mod trait_ext {
-    use crate::client::{Error, ExtendedBufRead, MessageKind, Transport, WriteMode};
-    use bstr::BString;
     use std::io::Write;
+    use bstr::BString;
+    use crate::client::{Error, ExtendedBufRead, MessageKind, Transport, WriteMode};
     /// An extension trait to add more methods to everything implementing [`Transport`].
     pub trait TransportV2Ext {
         /// Invoke a protocol V2 style `command` with given `capabilities` and optional command specific `arguments`.
         }
     }
 }
-pub use trait_ext::TransportV2Ext;
 mod box_impl {
+    use std::ops::{Deref, DerefMut};
     use crate::{
         client::{self, Error, Identity, MessageKind, RequestWriter, SetServiceResponse, WriteMode},
         Protocol, Service,
     };
-    use std::ops::{Deref, DerefMut};
     // Would be nice if the box implementation could auto-forward to all implemented traits.
     impl<T: client::Transport + ?Sized> client::Transport for Box<T> {

git-transport/src/client/mod.rs+14−8

-#[cfg(feature = "blocking-client")]
+#[cfg(all(not(feature = "blocking-client"), feature = "async-client"))]
-mod blocking_io;
+pub use async_io::{SetServiceResponse, Transport};
 #[cfg(all(feature = "blocking-client", feature = "http-client-curl"))]
 pub use blocking_io::http;
 #[cfg(feature = "blocking-client")]
 pub use blocking_io::{
-    connect, file, git, ssh, ExtendedBufRead, HandleProgress, RequestWriter, SetServiceResponse, Transport,
+    connect, file, git, ssh, ExtendedBufRead, HandleProgress, SetServiceResponse, Transport, TransportV2Ext,
-    TransportV2Ext,
 };
 #[cfg(feature = "blocking-client")]
 #[doc(inline)]
 #[cfg(all(not(feature = "blocking-client"), feature = "async-client"))]
 mod async_io;
-#[cfg(all(not(feature = "blocking-client"), feature = "async-client"))]
+#[cfg(feature = "blocking-client")]
-pub use async_io::{SetServiceResponse, Transport};
+mod blocking_io;
+///
+pub mod capabilities;
+#[doc(inline)]
+pub use capabilities::Capabilities;
 mod non_io_types;
 pub use non_io_types::{Error, Identity, MessageKind, WriteMode};
 ///
-pub mod capabilities;
+#[cfg(feature = "blocking-client")]
+pub mod request;
 #[doc(inline)]
-pub use capabilities::Capabilities;
+#[cfg(feature = "blocking-client")]
+pub use request::RequestWriter;

git-transport/src/client/request.rsrenamed from git-transport/src/client/blocking_io/request.rs+10−6

     }
 }
+/// methods with bonds to IO
 impl<'a> RequestWriter<'a> {
     /// Create a new instance from a `writer` (commonly a socket), a `reader` into which to transform once the
     /// writes are finished, along with configuration for the `write_mode` and information about which message to write
         }
     }
-    /// Discard the ability to write and turn this instance into the reader for obtaining the other side's response.
-    pub fn into_read(mut self) -> io::Result<Box<dyn ExtendedBufRead + 'a>> {
-        self.write_message(self.on_into_read)?;
-        Ok(self.reader)
-    }
     /// Write the given message as packet line.
     pub fn write_message(&mut self, message: MessageKind) -> io::Result<()> {
         match message {
         .map(|_| ())
     }
 }
+/// TODO: make this general
+impl<'a> RequestWriter<'a> {
+    /// Discard the ability to write and turn this instance into the reader for obtaining the other side's response.
+    pub fn into_read(mut self) -> io::Result<Box<dyn ExtendedBufRead + 'a>> {
+        self.write_message(self.on_into_read)?;
+        Ok(self.reader)
+    }
+}