Enum Spec 

#[non_exhaustive]
pub enum Spec {
    Device(PathBuf),
    Label(String),
    Uuid(String),
    PartLabel(String),
    PartUuid(String),
    Id(String),
    NetworkMount {
        host: String,
        path: PathBuf,
    },
    Keyword(String),
}

Filesystem source identifier — fstab(5) field 1.

Corresponds to libmount: fs->source + fs->tagname/fs->tagval.

Examples

let spec = Spec::parse("UUID=abc-123").unwrap();
assert!(matches!(spec, Spec::Uuid(_)));
assert!(spec.is_tag());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Device(PathBuf)

Block device path: /dev/sda1, /dev/disk/by-uuid/...

Label(String)

Filesystem label: LABEL=Boot

Uuid(String)

Filesystem UUID: UUID=3e6be9de-... (preserves original case)

PartLabel(String)

GPT partition label: PARTLABEL=System

PartUuid(String)

GPT partition UUID: PARTUUID=...

Id(String)

👎Deprecated:

ID= tag is not strictly defined and depends on udev rules/hardware

Hardware block device ID (deprecated, per fstab(5) and mount(8)).

The ID= tag is not strictly defined and depends on udev rules or hardware topology. Prefer UUID=, PARTUUID=, or /dev/disk/by-* paths instead.

NetworkMount

NFS-style network mount: host:/path

Fields

host: String

Remote host (hostname, IP address, or bracketed IPv6 address).

path: PathBuf

Exported path on the remote host.

Keyword(String)

Pseudo-filesystem keyword: proc, tmpfs, sysfs, none, etc.

Implementations

impl Spec

pub fn parse(raw: &str) -> Result<Self, SpecError>

Parse a decoded spec string into a typed Spec.

This function accepts already-decoded strings. If you need to parse escape-encoded strings from an fstab file, use parse_raw instead (crate-internal helper that calls decode_escapes before parsing).

Examples

// Device path
let spec = Spec::parse("/dev/sda1").unwrap();
assert!(matches!(spec, Spec::Device(_)));

// Tag-based identifier (case-insensitive tag prefix)
let spec = Spec::parse("uuid=abc-123").unwrap();
assert_eq!(spec, Spec::Uuid("abc-123".into()));

// Label
let spec = Spec::parse("LABEL=Boot").unwrap();
assert_eq!(spec, Spec::Label("Boot".into()));

// NFS network mount
let spec = Spec::parse("server:/export").unwrap();
assert!(matches!(spec, Spec::NetworkMount { .. }));

// Pseudo-filesystem
let spec = Spec::parse("proc").unwrap();
assert!(spec.is_pseudo());

Errors

Returns SpecError::Empty if the input is empty.

pub fn is_tag(&self) -> bool

Returns true if this is a tag-based identifier (LABEL/UUID/PARTLABEL/PARTUUID/ID).

pub fn is_pseudo(&self) -> bool

Returns true if this is a pseudo-filesystem (no backing block device).

pub fn tag_name(&self) -> Option<&'static str>

Returns the tag prefix name for tag-based identifiers.

Returns Some("LABEL"), Some("UUID"), Some("PARTLABEL"), Some("PARTUUID"), or Some("ID") for tag variants, or None for non-tag variants.

Examples

let spec = Spec::parse("UUID=abc-123").unwrap();
assert_eq!(spec.tag_name(), Some("UUID"));
assert_eq!(Spec::parse("/dev/sda1").unwrap().tag_name(), None);

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

Returns the tag value for tag-based identifiers.

Returns Some(value) for tag variants (e.g., "abc-123" for UUID=abc-123), or None for non-tag variants.

Examples

let spec = Spec::parse("LABEL=Boot").unwrap();
assert_eq!(spec.tag_value(), Some("Boot"));
assert_eq!(Spec::parse("proc").unwrap().tag_value(), None);

Trait Implementations

impl Clone for Spec

fn clone(&self) -> Spec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Spec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Spec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Spec

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

Formats the value using the given formatter.

impl FromStr for Spec

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse a string into a Spec.

This is equivalent to Spec::parse.

type Err = SpecError

The associated error which can be returned from parsing.

impl Hash for Spec

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 Spec

fn eq(&self, other: &Spec) -> 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 Spec

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for Spec

Try to convert a string into a Spec.

Equivalent to Spec::parse.

type Error = SpecError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Spec

impl StructuralPartialEq for Spec