Factored into separate crate

src/needminbuffer.rs

@@ -0,0 +1,111 @@
+use crate::filechunkread::FileChunkRead;
+use futures_util::Stream;
+use futures_util::StreamExt;
+use netpod::histo::HistoLog2;
+use netpod::log::*;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+
+#[derive(Debug, thiserror::Error)]
+#[cstm(name = "NeedMinBuffer")]
+pub enum Error {}
+
+pub struct NeedMinBuffer {
+    inp: Pin<Box<dyn Stream<Item = Result<FileChunkRead, items_0::streamitem::SitemErrTy>> + Send>>,
+    need_min: u32,
+    left: Option<FileChunkRead>,
+    buf_len_histo: HistoLog2,
+    errored: bool,
+    completed: bool,
+}
+
+impl NeedMinBuffer {
+    pub fn new(
+        inp: Pin<Box<dyn Stream<Item = Result<FileChunkRead, items_0::streamitem::SitemErrTy>> + Send>>,
+    ) -> Self {
+        Self {
+            inp,
+            need_min: 1,
+            left: None,
+            buf_len_histo: HistoLog2::new(8),
+            errored: false,
+            completed: false,
+        }
+    }
+
+    pub fn put_back(&mut self, buf: FileChunkRead) {
+        assert!(self.left.is_none());
+        self.left = Some(buf);
+    }
+
+    pub fn set_need_min(&mut self, need_min: u32) {
+        self.need_min = need_min;
+    }
+}
+
+// TODO collect somewhere else
+impl Drop for NeedMinBuffer {
+    fn drop(&mut self) {
+        debug!("NeedMinBuffer-drop {{ buf_len_histo: {:?} }}", self.buf_len_histo);
+    }
+}
+
+impl Stream for NeedMinBuffer {
+    type Item = Result<FileChunkRead, items_0::streamitem::SitemErrTy>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        use Poll::*;
+        loop {
+            break if self.completed {
+                panic!("NeedMinBuffer  poll_next on completed");
+            } else if self.errored {
+                self.completed = true;
+                return Ready(None);
+            } else {
+                match self.inp.poll_next_unpin(cx) {
+                    Ready(Some(Ok(mut fcr))) => {
+                        self.buf_len_histo.ingest(fcr.buf().len() as u32);
+                        //info!("NeedMinBuffer got buf  len {}", fcr.buf.len());
+                        match self.left.take() {
+                            Some(mut lfcr) => {
+                                // TODO measure:
+                                lfcr.buf_mut().unsplit(fcr.buf_take());
+                                *lfcr.duration_mut() += *fcr.duration();
+                                let fcr = lfcr;
+                                if fcr.buf().len() as u32 >= self.need_min {
+                                    //info!("with left ready  len {}  need_min {}", buf.len(), self.need_min);
+                                    Ready(Some(Ok(fcr)))
+                                } else {
+                                    //info!("with left not enough  len {}  need_min {}", buf.len(), self.need_min);
+                                    self.left.replace(fcr);
+                                    continue;
+                                }
+                            }
+                            None => {
+                                if fcr.buf().len() as u32 >= self.need_min {
+                                    //info!("simply ready  len {}  need_min {}", buf.len(), self.need_min);
+                                    Ready(Some(Ok(fcr)))
+                                } else {
+                                    //info!("no previous leftover, need more  len {}  need_min {}", buf.len(), self.need_min);
+                                    self.left.replace(fcr);
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    Ready(Some(Err(e))) => {
+                        self.errored = true;
+                        Ready(Some(Err(e.into())))
+                    }
+                    Ready(None) => {
+                        // TODO collect somewhere
+                        debug!("NeedMinBuffer  histo: {:?}", self.buf_len_histo);
+                        Ready(None)
+                    }
+                    Pending => Pending,
+                }
+            };
+        }
+    }
+}