Add more necessary logic for bridging with rusqlite-vfs.

Author: jalcine

src/filesystem.rs

@@ -21,8 +21,6 @@ pub trait FileSystem: Debug + Sync + Send + 'static {
     fn create_dir(&self, path: &str) -> VfsResult<()>;
     /// Opens the file at this path for reading
     fn open_file(&self, path: &str) -> VfsResult<Box<dyn SeekAndRead>>;
-    /// Opens the file at this path for reading and writing
-    fn update_file(&self, path: &str) -> VfsResult<Box<dyn SeekAndReadAndWrite>>;
     /// Creates a file at this path for writing
     fn create_file(&self, path: &str) -> VfsResult<Box<dyn Write>>;
     /// Opens the file at this path for appending
@@ -47,6 +45,32 @@ pub trait FileSystem: Debug + Sync + Send + 'static {
     fn move_dir(&self, _src: &str, _dest: &str) -> VfsResult<()> {
         Err(VfsError::NotSupported)
     }
+
+    /// Informs the filesystem to 'flush' its potentially cached information.
+    ///
+    /// This is, by default, queries the current size.
+    fn size_hint(&self, path: &str) -> VfsResult<u64> {
+        self.metadata(path).map(|f| f.len)
+    }
+
+    /// Informs the filesystem to 'flush' its potentially cached information.
+    ///
+    /// This is, by default, a no-op.
+    fn sync(&self, _path: &str) -> VfsResult<()> {
+        Ok(())
+    }
+
+    /// Set a size hint for the associated path.
+    ///
+    /// This is, by default, a no-op.
+    fn set_size_hint(&self, _hint: usize, _path: &str) -> VfsResult<()> {
+        Ok(())
+    }
+
+    /// Opens the file at this path for reading and writing
+    fn update_file(&self, _path: &str) -> VfsResult<Box<dyn SeekAndReadAndWrite>> {
+        Err(VfsError::NotSupported)
+    }
 }
 
 impl<T: FileSystem> From<T> for VfsPath {

src/impls/memory.rs

@@ -120,48 +120,6 @@ impl Seek for ReadableFile {
     }
 }
 
-struct WriteableAndReadableFile {
-    content: Cursor<Vec<u8>>,
-    destination: String,
-    fs: MemoryFsHandle,
-}
-
-impl Write for WriteableAndReadableFile {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        self.content.write(buf)
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        self.content.flush()
-    }
-}
-
-impl Read for WriteableAndReadableFile {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        self.content.read(buf)
-    }
-}
-
-impl Seek for WriteableAndReadableFile {
-    fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> {
-        self.content.seek(pos)
-    }
-}
-
-impl Drop for WriteableAndReadableFile {
-    fn drop(&mut self) {
-        let mut content = vec![];
-        swap(&mut content, self.content.get_mut());
-        self.fs.write().unwrap().files.insert(
-            self.destination.clone(),
-            MemoryFile {
-                file_type: VfsFileType::File,
-                content: Arc::new(content),
-            },
-        );
-    }
-}
-
 impl FileSystem for MemoryFS {
     fn read_dir(&self, path: &str) -> VfsResult<Box<dyn Iterator<Item = String>>> {
         let prefix = format!("{}/", path);
@@ -219,24 +177,6 @@ impl FileSystem for MemoryFS {
         }))
     }
 
-    fn update_file(&self, path: &str) -> VfsResult<Box<dyn crate::SeekAndReadAndWrite>> {
-        let handle = self.handle.read().unwrap();
-        let file = handle
-            .files
-            .get(path)
-            .ok_or_else(|| VfsError::FileNotFound {
-                path: path.to_string(),
-            })?;
-        ensure_file(file)?;
-        let mut content = Cursor::new(file.content.as_ref().clone());
-        content.seek(SeekFrom::Start(0))?;
-        Ok(Box::new(WriteableAndReadableFile {
-            content,
-            destination: path.to_string(),
-            fs: self.handle.clone(),
-        }))
-    }
-
     fn create_file(&self, path: &str) -> VfsResult<Box<dyn Write>> {
         self.ensure_has_parent(path)?;
         let content = Arc::new(Vec::<u8>::new());

src/path.rs

@@ -317,9 +317,9 @@ impl VfsPath {
     ///
     /// assert_eq!(&result, "Hello, world!");
     ///
-    /// handle.rewind()?;
+    /// handle.seek(SeekFrom::Start(0))?;
     /// handle.write(b"Goodnight, world.")?;
-    /// handle.rewind()?;
+    /// handle.seek(SeekFrom::Start(0))?;
     ///
     /// let mut result2 = String::new();
     /// handle.read_to_string(&mut result2)?;
@@ -873,6 +873,14 @@ impl VfsPath {
         })?;
         Ok(())
     }
+
+    pub fn sync(&mut self) -> VfsResult<()> {
+        self.fs.fs.sync(&self.path)
+    }
+
+    pub fn set_size_hint(&mut self, size_hint: usize) -> VfsResult<()> {
+        self.fs.fs.set_size_hint(size_hint, &self.path)
+    }
 }
 
 /// An iterator for recursively walking a file hierarchy