Struct Entry 

pub struct Entry(/* private fields */);

A key-value entry in a section

Implementations

impl Entry

pub fn new(key: &str, value: &str) -> Entry

Create a new entry with key=value

pub fn key(&self) -> Option<String>

Get the key name

pub fn value(&self) -> Option<String>

Get the value (handles line continuations)

pub fn raw_value(&self) -> Option<String>

Get the raw value as it appears in the file (including line continuations)

pub fn unescape_value(&self) -> Option<String>

Get the value with escape sequences processed

This processes C-style escape sequences as defined in the systemd specification:

• \n - newline
• \t - tab
• \r - carriage return
• \\ - backslash
• \" - double quote
• \' - single quote
• \xhh - hexadecimal byte (2 digits)
• \nnn - octal byte (3 digits)
• \unnnn - Unicode codepoint (4 hex digits)
• \Unnnnnnnn - Unicode codepoint (8 hex digits)

pub fn escape_value(value: &str) -> String

Escape a string value for use in systemd unit files

This escapes special characters that need escaping in systemd values:

• backslash (\) becomes \\
• newline (\n) becomes \n
• tab (\t) becomes \t
• carriage return (\r) becomes \r
• double quote (") becomes \"

pub fn is_quoted(&self) -> Option<char>

Check if the value is quoted (starts and ends with matching quotes)

Returns the quote character if the value is quoted, None otherwise. Systemd supports both double quotes (") and single quotes (').

pub fn unquoted_value(&self) -> Option<String>

Get the value with quotes removed (if present)

According to systemd specification, quotes are removed when processing values. This method returns the value with outer quotes stripped if present.

pub fn quoted_value(&self) -> Option<String>

Get the value with quotes preserved as they appear in the file

This is useful when you want to preserve the exact quoting style.

pub fn value_as_list(&self) -> Vec<String>

Parse the value as a space-separated list

Many systemd directives use space-separated lists (e.g., Wants=, After=, Before=). This method splits the value on whitespace and returns a vector of strings.

Empty values return an empty vector.

pub fn value_as_bool(&self) -> Option<bool>

Parse the value as a boolean

According to systemd specification, boolean values accept:

• Positive: 1, yes, true, on
• Negative: 0, no, false, off

Returns None if the value is not a valid boolean or if the entry has no value.

Example

let unit = SystemdUnit::from_str("[Service]\nRemainAfterExit=yes\n").unwrap();
let section = unit.get_section("Service").unwrap();
let entry = section.entries().next().unwrap();
assert_eq!(entry.value_as_bool(), Some(true));

pub fn format_bool(value: bool) -> &'static str

Format a boolean value for use in systemd unit files

This converts a boolean to the canonical systemd format:

• true becomes "yes"
• false becomes "no"

Example

assert_eq!(Entry::format_bool(true), "yes");
assert_eq!(Entry::format_bool(false), "no");

pub fn expand_specifiers(&self, context: &SpecifierContext) -> Option<String>

Expand systemd specifiers in the value

This replaces systemd specifiers like %i, %u, %h with their values from the provided context.

Example

let unit = SystemdUnit::from_str("[Service]\nWorkingDirectory=/var/lib/%i\n").unwrap();
let section = unit.get_section("Service").unwrap();
let entry = section.entries().next().unwrap();

let mut ctx = SpecifierContext::new();
ctx.set("i", "myinstance");

assert_eq!(entry.expand_specifiers(&ctx), Some("/var/lib/myinstance".to_string()));

pub fn set_value(&self, new_value: &str)

Set a new value for this entry, modifying it in place

This replaces the entry’s value while preserving its key and position in the section. This is useful when iterating over entries and modifying them selectively.

Example

let input = r#"[Unit]
After=network.target syslog.target
Wants=foo.service
After=remote-fs.target
"#;
let unit = SystemdUnit::from_str(input).unwrap();
let section = unit.get_section("Unit").unwrap();

for entry in section.entries() {
    if entry.key().as_deref() == Some("After") {
        let values = entry.value_as_list();
        let filtered: Vec<_> = values.iter()
            .filter(|v| v.as_str() != "syslog.target")
            .map(|s| s.as_str())
            .collect();
        entry.set_value(&filtered.join(" "));
    }
}

let section = unit.get_section("Unit").unwrap();
assert_eq!(section.get_all("After"), vec!["network.target", "remote-fs.target"]);

pub fn syntax(&self) -> &SyntaxNode<Lang>

Get the raw syntax node

pub fn line(&self) -> usize

Get the line number (0-indexed) where this node starts.

pub fn column(&self) -> usize

Get the column number (0-indexed, in bytes) where this node starts.

pub fn line_col(&self) -> (usize, usize)

Get both line and column (0-indexed) where this node starts. Returns (line, column) where column is measured in bytes from the start of the line.

Trait Implementations

impl AstNode for Entry

type Language = Lang

fn can_cast(kind: SyntaxKind) -> bool

fn cast(node: SyntaxNode<Lang>) -> Option<Self>

fn syntax(&self) -> &SyntaxNode<Lang>

fn clone_for_update(&self) -> Self

where Self: Sized,

fn clone_subtree(&self) -> Self

where Self: Sized,

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 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 Eq for Entry

impl StructuralPartialEq for Entry