Struct Entry 

pub struct Entry {
    pub spec: Spec,
    pub file: MountPoint,
    pub vfstype: FsType,
    pub options: Options,
    pub freq: u32,
    pub passno: u32,
    pub comment: Option<String>,
}

A single fstab entry — corresponds to libmount struct libmnt_fs.

Each entry represents one line in /etc/fstab, consisting of six whitespace-separated fields plus an optional preceding comment block.

Examples

let entry = Entry {
    spec: Spec::parse("UUID=root").unwrap(),
    file: MountPoint::new("/").unwrap(),
    vfstype: FsType::parse("ext4").unwrap(),
    options: Options::parse("defaults").unwrap(),
    freq: 0,
    passno: 1,
    comment: None,
};
assert!(entry.is_root());

Fields

spec: Spec

Filesystem source (device, UUID, label, etc.) — fstab(5) field 1.

file: MountPoint

Mount point path — fstab(5) field 2 (fs_file).

vfstype: FsType

Filesystem type — fstab(5) field 3 (fs_vfstype).

options: Options

Mount options — fstab(5) field 4 (fs_mntops).

freq: u32

Dump frequency — fstab(5) field 5 (fs_freq). Default: 0.

passno: u32

Filesystem check order — fstab(5) field 6 (fs_passno). Default: 0.

comment: Option<String>

Comment lines immediately above this entry.

Implementations

impl Entry

pub fn new( spec: Spec, file: MountPoint, vfstype: FsType, options: Options, ) -> Self

Create a new entry with the required fields.

freq and passno default to 0, and comment defaults to None.

Examples

let entry = Entry::new(
    Spec::parse("UUID=root").unwrap(),
    MountPoint::new("/").unwrap(),
    FsType::parse("ext4").unwrap(),
    Options::parse("defaults").unwrap(),
);
assert!(entry.file.is_root());
assert_eq!(entry.freq, 0);
assert_eq!(entry.passno, 0);
assert!(entry.comment.is_none());

pub fn builder() -> EntryBuilder

Create an EntryBuilder for ergonomic construction with optional fields.

Examples

let entry = Entry::builder()
    .spec(Spec::parse("UUID=root").unwrap())
    .file(MountPoint::new("/").unwrap())
    .vfstype(FsType::parse("ext4").unwrap())
    .options(Options::parse("defaults,noatime").unwrap())
    .freq(0)
    .passno(1)
    .comment("# Root filesystem")
    .build()
    .unwrap();
assert!(entry.is_root());

pub fn is_swap(&self) -> bool

Whether this is a swap entry.

pub fn is_bind_mount(&self) -> bool

Whether this is a bind mount.

pub fn is_root(&self) -> bool

Whether this is the root filesystem entry.

Returns true only when the mount point is / and passno == 1, following the fstab(5) convention that the root filesystem must have fs_passno set to 1. An entry at / with passno != 1 is not considered the root entry by this method.

pub fn is_network(&self) -> bool

Whether this is a network filesystem.

pub fn comment(&self) -> Option<&str>

Get the comment lines before this entry, if any.

Trait Implementations

impl Clone for Entry

fn clone(&self) -> Entry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Entry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Entry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Entry

Format an Entry as an fstab data line.

The output includes the spec (with escape encoding), mount point (with escape encoding), filesystem type, and options. If either freq or passno is non-zero, both are included.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Entry

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Entry

fn eq(&self, other: &Entry) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Entry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Entry

impl StructuralPartialEq for Entry