rust/hg-core/src/revlog/file_io.rs

52184:735bf027dd1d

//! Helpers for revlog file reading and writing.

use std::{
    cell::RefCell,
    fs::File,
    io::{Read, Seek, SeekFrom, Write},
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
};

use crate::{
    errors::{HgError, IoResultExt},
    vfs::Vfs,
};

/// Wraps accessing arbitrary chunks of data within a file and reusing handles.
/// This is currently useful for accessing a revlog's data file, only reading
/// the ranges that are currently relevant, like a sort of basic and manual

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

/// Holds an open [`File`] and the related data. This can be used for reading
/// and writing. Writes can be delayed to a buffer before touching the disk,
/// if relevant (in the changelog case), but reads are transparent.
pub struct FileHandle {
    /// The actual open file
    pub file: File,
    /// The VFS with which the file was opened
    vfs: Box<dyn Vfs>,
    /// Filename of the open file, relative to the repo root
    filename: PathBuf,
    /// Buffer of delayed entry writes to the changelog index. This points

        filename: impl AsRef<Path>,
        create: bool,
        write: bool,
    ) -> Result<Self, HgError> {
        let file = if create {
            vfs.create(filename.as_ref())?
        } else if write {
            vfs.open(filename.as_ref())?
        } else {
            vfs.open_read(filename.as_ref())?
        };

        filename: impl AsRef<Path>,
        create: bool,
        delayed_buffer: Arc<Mutex<DelayedBuffer>>,
    ) -> Result<Self, HgError> {
        let mut file = if create {
            vfs.create(filename.as_ref())?
        } else {
            vfs.open(filename.as_ref())?
        };
        let size = vfs.file_size(&file)?;
        let offset = file

            delayed_buffer: Some(delayed_buffer),
            file,
        })
    }

    /// Wrap an existing [`File`]
    pub fn from_file(
        file: File,
        vfs: Box<dyn Vfs>,
        filename: impl AsRef<Path>,
    ) -> Self {
        Self {
            vfs,

            delayed_buffer: None,
            file,
        }
    }

    /// Wrap an existing [`File`], but writes go to a [`DelayedBuffer`].
    pub fn from_file_delayed(
        mut file: File,
        vfs: Box<dyn Vfs>,
        filename: impl AsRef<Path>,
        delayed_buffer: Arc<Mutex<DelayedBuffer>>,
    ) -> Result<Self, HgError> {
        let size = vfs.file_size(&file)?;

52185:8d35941689af

//! Helpers for revlog file reading and writing.

use std::{
    cell::RefCell,
    io::{Read, Seek, SeekFrom, Write},
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
};

use crate::{
    errors::{HgError, IoResultExt},
    vfs::{Vfs, VfsFile},
};

/// Wraps accessing arbitrary chunks of data within a file and reusing handles.
/// This is currently useful for accessing a revlog's data file, only reading
/// the ranges that are currently relevant, like a sort of basic and manual

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

/// Holds an open [`VfsFile`] and the related data. This can be used for
/// reading and writing. Writes can be delayed to a buffer before touching
/// the disk, if relevant (in the changelog case), but reads are transparent.
pub struct FileHandle {
    /// The actual open file
    pub file: VfsFile,
    /// The VFS with which the file was opened
    vfs: Box<dyn Vfs>,
    /// Filename of the open file, relative to the repo root
    filename: PathBuf,
    /// Buffer of delayed entry writes to the changelog index. This points

        filename: impl AsRef<Path>,
        create: bool,
        write: bool,
    ) -> Result<Self, HgError> {
        let file = if create {
            vfs.create(filename.as_ref(), false)?
        } else if write {
            vfs.open(filename.as_ref())?
        } else {
            vfs.open_read(filename.as_ref())?
        };

        filename: impl AsRef<Path>,
        create: bool,
        delayed_buffer: Arc<Mutex<DelayedBuffer>>,
    ) -> Result<Self, HgError> {
        let mut file = if create {
            vfs.create(filename.as_ref(), false)?
        } else {
            vfs.open(filename.as_ref())?
        };
        let size = vfs.file_size(&file)?;
        let offset = file

            delayed_buffer: Some(delayed_buffer),
            file,
        })
    }

    /// Wrap an existing [`VfsFile`]
    pub fn from_file(
        file: VfsFile,
        vfs: Box<dyn Vfs>,
        filename: impl AsRef<Path>,
    ) -> Self {
        Self {
            vfs,

            delayed_buffer: None,
            file,
        }
    }

    /// Wrap an existing [`VfsFile`], but writes go to a [`DelayedBuffer`].
    pub fn from_file_delayed(
        mut file: VfsFile,
        vfs: Box<dyn Vfs>,
        filename: impl AsRef<Path>,
        delayed_buffer: Arc<Mutex<DelayedBuffer>>,
    ) -> Result<Self, HgError> {
        let size = vfs.file_size(&file)?;