[protocol] FAIL2: lifetime issues with loop

The loop is needed to handle interrupt errors correctly. Writing it differently has no effect either, that's good I guess

Sebastian Thiel committed 6 years ago

Commit c2ff0701 parent 0f468f93 files · +19 −18Browse files

Showing the changes to git-protocol/src (1 of 3 files). Show all

Unified · Split

git-protocol/src/packet_line/mod.rs+18−17

     /// start of whatever comes next.
     pub struct Reader<T> {
         pub inner: T,
-        buf: Option<Vec<u8>>,
+        buf: Vec<u8>,
         occupied: Option<std::ops::Range<usize>>,
+        is_done: bool,
     }
     impl<T> Reader<T>
         pub fn new(inner: T) -> Self {
             Reader {
                 inner,
-                buf: Some({
+                buf: {
                     let mut v = Vec::with_capacity(MAX_LINE_LEN);
                     v.resize(MAX_LINE_LEN, 0);
                     v
-                }),
+                },
                 occupied: None,
+                is_done: false,
             }
         }
         fn read_line_inner<'a>(
             reader: &mut T,
             occupied: &mut Option<std::ops::Range<usize>>,
         }
         pub fn read_line(&mut self) -> Option<io::Result<Result<Borrowed, decode::Error>>> {
-            match self.buf.as_mut() {
+            if self.is_done {
-                Some(buf) => {
+                return None;
-                    loop {
+            }
-                        match Self::read_line_inner(&mut self.inner, &mut self.occupied, buf) {
+            Some(loop {
-                            Ok(Ok(line)) if line == Borrowed::Flush => {
+                match Self::read_line_inner(&mut self.inner, &mut self.occupied, &mut self.buf) {
-                                self.buf = None;
+                    Ok(Ok(line)) if line == Borrowed::Flush => {
-                                return None;
+                        self.is_done = true;
-                            }
+                        return None;
-                            Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
-                            // res => return Some(res),
-                            res => unimplemented!("tst"),
-                        }
                     }
+                    Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
+                    res => break res,
+                    // res => unimplemented!("tst"),
                 }
-                None => None,
+            })
-            }
         }
     }
 }