Initial Dever 0.0.1

test/rust/performance/resource/reference.rs

@@ -0,0 +1,111 @@
+// 独立 Rust 参照保留文件的跨线程别名及同步流的共享游标，不调用 Dever I/O。
+use std::{
+    cell::RefCell,
+    fs,
+    io::Read,
+    rc::Rc,
+    sync::{Arc, Mutex},
+};
+
+#[derive(Clone)]
+struct ReferenceFile(Arc<Mutex<Option<fs::File>>>);
+
+impl ReferenceFile {
+    fn open(path: &str) -> Result<Self, String> {
+        fs::File::open(path)
+            .map(|file| Self(Arc::new(Mutex::new(Some(file)))))
+            .map_err(|error| error.to_string())
+    }
+
+    fn read(&self, limit: i64) -> Result<Option<Vec<u8>>, String> {
+        let limit = usize::try_from(limit)
+            .ok()
+            .filter(|limit| *limit > 0)
+            .ok_or("read limit must be positive")?;
+        let mut guard = self.0.lock().map_err(|_| "file lock poisoned")?;
+        let file = guard.as_mut().ok_or("file is closed")?;
+        let mut bytes = Vec::new();
+        bytes
+            .try_reserve_exact(limit)
+            .map_err(|error| error.to_string())?;
+        bytes.resize(limit, 0);
+        let count = file.read(&mut bytes).map_err(|error| error.to_string())?;
+        bytes.truncate(count);
+        Ok((count != 0).then_some(bytes))
+    }
+
+    fn close(&self) -> Result<(), String> {
+        drop(
+            self.0
+                .lock()
+                .map_err(|_| "file lock poisoned")?
+                .take()
+                .ok_or("file is closed")?,
+        );
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+struct ReferenceStream(Rc<RefCell<Option<(ReferenceFile, i64)>>>);
+
+impl ReferenceStream {
+    fn new(file: &ReferenceFile, limit: i64) -> Result<Self, String> {
+        usize::try_from(limit)
+            .ok()
+            .filter(|limit| *limit > 0)
+            .ok_or("read limit must be positive")?;
+        if file.0.lock().map_err(|_| "file lock poisoned")?.is_none() {
+            return Err("file is closed".into());
+        }
+        Ok(Self(Rc::new(RefCell::new(Some((file.clone(), limit))))))
+    }
+
+    fn next(&self) -> Option<Result<Vec<u8>, String>> {
+        let mut source = self.0.borrow_mut();
+        let (file, limit) = source.as_ref()?;
+        match file.read(*limit) {
+            Ok(Some(bytes)) => Some(Ok(bytes)),
+            Ok(None) => {
+                *source = None;
+                None
+            }
+            Err(error) => {
+                *source = None;
+                Some(Err(error))
+            }
+        }
+    }
+
+    fn close(&self) {
+        *self.0.borrow_mut() = None;
+    }
+}
+
+fn reference_count(bytes: &[u8], total: i64) -> Result<i64, String> {
+    bytes.iter().try_fold(total, |sum, byte| {
+        sum.checked_add(i64::from(*byte))
+            .ok_or_else(|| "integer overflow".into())
+    })
+}
+
+fn reference_consume(path: &str, limit: i64, partial: bool) -> Result<i64, String> {
+    let file = ReferenceFile::open(path)?;
+    let stream = ReferenceStream::new(&file, limit)?;
+    let alias = partial.then(|| stream.clone());
+    let mut total = 0;
+    if partial {
+        if let Some(bytes) = stream.next() {
+            total = reference_count(&bytes?, total)?;
+        }
+    }
+    while let Some(bytes) = alias.as_ref().unwrap_or(&stream).next() {
+        total = reference_count(&bytes?, total)?;
+    }
+    if partial {
+        stream.close();
+        alias.as_ref().unwrap().close();
+    }
+    file.close()?;
+    Ok(total)
+}