Trait FileOptionsExt

pub trait FileOptionsExt {
    // Required methods
    fn lock_share(&mut self, mode: FileShare) -> &mut Self;
    fn lock_access(&mut self, access: FileAccess) -> &mut Self;
    fn custom_flags2(
        &mut self,
        flags: impl IntoIterator<Item = FileCustom>,
    ) -> &mut Self;
    fn attributes2(
        &mut self,
        attributes: impl IntoIterator<Item = FileAttribute>,
    ) -> &mut Self;
    fn security_qos_flags2(
        &mut self,
        flags: impl IntoIterator<Item = FileSecurity>,
    ) -> &mut Self;
}

Extension trait for std::fs::OpenOptions which provides allocation, duplication and locking methods.

Required Methods

fn lock_share(&mut self, mode: FileShare) -> &mut Self

锁共享

use e_utils::{
  fs::{FileShare, FileExt, FileOptionsExt},
  parse::AutoPath as _,
  system::time::{TimezoneStrategy, LOG_FILE_DATE_FORMAT},
};
use std::{
  fs,
  io::{self, Write},
  path::Path,
  time::Duration,
};
/// 只读不可删和写入
fn main() -> Result<(), io::Error> {
  let now = TimezoneStrategy::UseUtc
    .get_now()
    .format(LOG_FILE_DATE_FORMAT);
  let fpath = Path::new("logs").join(format!("test.{}.log", now));
  fpath.auto_create_dir().unwrap();
  let mut f = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .read(true)
    .append(true)
    .lock_share(FileShare::Read)
    .open(&fpath)?;
  f.write("locked\n".as_bytes())?;
  for i in 0..30 {
    let _ = f
      .write(format!("{i}.locke write\n").as_bytes())
      .inspect_err(|e| eprintln!("{}", e));
    if i > 20 {
      let _ = f.unlock();
    }
    let x = f.allocated_size()?;
    println!("allocated -> {x}");
    std::thread::sleep(Duration::from_millis(500));
  }
  Ok(())
}

fn lock_access(&mut self, access: FileAccess) -> &mut Self

接入锁

use e_utils::{
  fs::{FileAccess, FileExt, FileOptionsExt},
  parse::AutoPath as _,
  system::time::{TimezoneStrategy, LOG_FILE_DATE_FORMAT},
};
use std::{
  fs,
  io::{self, Write},
  path::Path,
  time::Duration,
};
/// 关闭时删除文件
fn main() -> Result<(), io::Error> {
  let now = TimezoneStrategy::UseUtc
    .get_now()
    .format(LOG_FILE_DATE_FORMAT);
  let fpath = Path::new("logs").join(format!("test.{}.log", now));
  fpath.auto_create_dir().unwrap();
  let mut f = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .read(true)
    .append(true)
    .lock_access(FileAccess::Empty)
    .open(&fpath)?;
  f.write("locked\n".as_bytes())?;
  for i in 0..30 {
    let _ = f
      .write(format!("{i}.locke write\n").as_bytes())
      .inspect_err(|e| eprintln!("{}", e));
    if i > 20 {
      let _ = f.unlock();
    }
    let x = f.allocated_size()?;
    println!("allocated -> {x}");
    std::thread::sleep(Duration::from_millis(500));
  }
  Ok(())
}

fn custom_flags2( &mut self, flags: impl IntoIterator<Item = FileCustom>, ) -> &mut Self

自定义标识 Example

use e_utils::{
  fs::{FileCustom, FileExt, FileOptionsExt},
  parse::AutoPath as _,
  system::time::{TimezoneStrategy, LOG_FILE_DATE_FORMAT},
};
use std::{
  fs,
  io::{self, Write},
  path::Path,
  time::Duration,
};
/// 关闭时删除文件
fn main() -> Result<(), io::Error> {
  let now = TimezoneStrategy::UseUtc
    .get_now()
    .format(LOG_FILE_DATE_FORMAT);
  let fpath = Path::new("logs").join(format!("test.{}.log", now));
  fpath.auto_create_dir().unwrap();
  let mut f = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .read(true)
    .append(true)
    .custom_flags2([
      FileCustom::DeleteOnClose,
      FileCustom::WriteThrough,
      FileCustom::RandomAccess,
    ])
    .open(&fpath)?;
  f.write("locked\n".as_bytes())?;
  for i in 0..30 {
    let _ = f
      .write(format!("{i}.locke write\n").as_bytes())
      .inspect_err(|e| eprintln!("{}", e));
    if i > 20 {
      let _ = f.unlock();
    }
    let x = f.allocated_size()?;
    println!("allocated -> {x}");
    std::thread::sleep(Duration::from_millis(500));
  }
  Ok(())
}

fn attributes2( &mut self, attributes: impl IntoIterator<Item = FileAttribute>, ) -> &mut Self

属性 Example

use e_utils::{
  fs::{FileAttribute, FileExt, FileOptionsExt},
  parse::AutoPath as _,
  system::time::{TimezoneStrategy, LOG_FILE_DATE_FORMAT},
};
use std::{
  fs,
  io::{self, Write},
  path::Path,
  time::Duration,
};
/// 隐藏文件
fn main() -> Result<(), io::Error> {
  let now = TimezoneStrategy::UseUtc
    .get_now()
    .format(LOG_FILE_DATE_FORMAT);
  let fpath = Path::new("logs").join(format!(".test.{}.log", now));
  fpath.auto_create_dir().unwrap();
  let mut f = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .read(true)
    .append(true)
    .attributes2([FileAttribute::Hidden])
    .open(&fpath)?;
  f.write("locked\n".as_bytes())?;
  for i in 0..30 {
    let _ = f
      .write(format!("{i}.locke write\n").as_bytes())
      .inspect_err(|e| eprintln!("{}", e));
    if i > 20 {
      let _ = f.unlock();
    }
    let x = f.allocated_size()?;
    println!("allocated -> {x}");
    std::thread::sleep(Duration::from_millis(500));
  }
  Ok(())
}

fn security_qos_flags2( &mut self, flags: impl IntoIterator<Item = FileSecurity>, ) -> &mut Self

安全QOS标识 Example

use e_utils::{
  fs::{FileSecurity, FileExt, FileOptionsExt},
  parse::AutoPath as _,
  system::time::{TimezoneStrategy, LOG_FILE_DATE_FORMAT},
};
use std::{
  fs,
  io::{self, Write},
  path::Path,
  time::Duration,
};
fn main() -> Result<(), io::Error> {
  let now = TimezoneStrategy::UseUtc
    .get_now()
    .format(LOG_FILE_DATE_FORMAT);
  let fpath = Path::new("logs").join(format!("test.{}.log", now));
  fpath.auto_create_dir().unwrap();
  let mut f = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .read(true)
    .append(true)
    .security_qos_flags2([FileSecurity::Identification])
    .open(&fpath)?;
  f.write("locked\n".as_bytes())?;
  for i in 0..30 {
    let _ = f
      .write(format!("{i}.locke write\n").as_bytes())
      .inspect_err(|e| eprintln!("{}", e));
    if i > 20 {
      let _ = f.unlock();
    }
    let x = f.allocated_size()?;
    println!("allocated -> {x}");
    std::thread::sleep(Duration::from_millis(500));
  }
  Ok(())
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FileOptionsExt for OpenOptions

fn lock_share(&mut self, _mode: FileShare) -> &mut OpenOptions

fn lock_access(&mut self, _access: FileAccess) -> &mut Self

fn custom_flags2( &mut self, _flags: impl IntoIterator<Item = FileCustom>, ) -> &mut Self

fn attributes2( &mut self, _attributes: impl IntoIterator<Item = FileAttribute>, ) -> &mut Self

fn security_qos_flags2( &mut self, _flags: impl IntoIterator<Item = FileSecurity>, ) -> &mut Self

Implementors