Write f64 values

netfetch/src/netbuf.rs

@@ -16,23 +16,32 @@ impl NetBuf {
         }
     }
 
+    pub fn state(&self) -> (usize, usize) {
+        (self.rp, self.wp)
+    }
+
     pub fn len(&self) -> usize {
+        self.check_invariant();
         self.wp - self.rp
     }
 
     pub fn cap(&self) -> usize {
+        self.check_invariant();
         self.buf.len()
     }
 
     pub fn wcap(&self) -> usize {
+        self.check_invariant();
         self.buf.len() - self.wp
     }
 
     pub fn data(&self) -> &[u8] {
+        self.check_invariant();
         &self.buf[self.rp..self.wp]
     }
 
     pub fn adv(&mut self, x: usize) -> Result<(), Error> {
+        self.check_invariant();
         if self.len() < x {
             return Err(Error::with_msg_no_trace("not enough bytes"));
         } else {
@@ -42,6 +51,7 @@ impl NetBuf {
     }
 
     pub fn wadv(&mut self, x: usize) -> Result<(), Error> {
+        self.check_invariant();
         if self.wcap() < x {
             return Err(Error::with_msg_no_trace("not enough space"));
         } else {
@@ -51,6 +61,7 @@ impl NetBuf {
     }
 
     pub fn read_u8(&mut self) -> Result<u8, Error> {
+        self.check_invariant();
         type T = u8;
         const TS: usize = std::mem::size_of::<T>();
         if self.len() < TS {
@@ -63,6 +74,7 @@ impl NetBuf {
     }
 
     pub fn read_u64(&mut self) -> Result<u64, Error> {
+        self.check_invariant();
         type T = u64;
         const TS: usize = std::mem::size_of::<T>();
         if self.len() < TS {
@@ -75,6 +87,7 @@ impl NetBuf {
     }
 
     pub fn read_bytes(&mut self, n: usize) -> Result<&[u8], Error> {
+        self.check_invariant();
         if self.len() < n {
             return Err(Error::with_msg_no_trace("not enough bytes"));
         } else {
@@ -85,12 +98,14 @@ impl NetBuf {
     }
 
     pub fn read_buf_for_fill(&mut self) -> ReadBuf {
+        self.check_invariant();
         self.rewind_if_needed();
         let read_buf = ReadBuf::new(&mut self.buf[self.wp..]);
         read_buf
     }
 
     pub fn rewind_if_needed(&mut self) {
+        self.check_invariant();
         if self.rp != 0 && self.rp == self.wp {
             self.rp = 0;
             self.wp = 0;
@@ -102,6 +117,7 @@ impl NetBuf {
     }
 
     pub fn put_slice(&mut self, buf: &[u8]) -> Result<(), Error> {
+        self.check_invariant();
         self.rewind_if_needed();
         if self.wcap() < buf.len() {
             return Err(Error::with_msg_no_trace("not enough space"));
@@ -113,6 +129,7 @@ impl NetBuf {
     }
 
     pub fn put_u8(&mut self, v: u8) -> Result<(), Error> {
+        self.check_invariant();
         type T = u8;
         const TS: usize = std::mem::size_of::<T>();
         self.rewind_if_needed();
@@ -126,6 +143,7 @@ impl NetBuf {
     }
 
     pub fn put_u64(&mut self, v: u64) -> Result<(), Error> {
+        self.check_invariant();
         type T = u64;
         const TS: usize = std::mem::size_of::<T>();
         self.rewind_if_needed();
@@ -137,4 +155,15 @@ impl NetBuf {
             Ok(())
         }
     }
+
+    fn check_invariant(&self) {
+        if self.wp > self.buf.len() {
+            eprintln!("ERROR  netbuf  wp {}  rp {}", self.wp, self.rp);
+            std::process::exit(87);
+        }
+        if self.rp > self.wp {
+            eprintln!("ERROR  netbuf  wp {}  rp {}", self.wp, self.rp);
+            std::process::exit(87);
+        }
+    }
 }