Struct Section 

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

A section in a systemd unit file (e.g., [Unit], [Service])

Implementations

impl Section

pub fn new(name: &str) -> Section

Create a new section with the given name

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

Get the name of the section

pub fn entries(&self) -> impl Iterator<Item = Entry>

Get all entries in the section

pub fn get(&self, key: &str) -> Option<String>

Get a specific entry by key

pub fn get_all(&self, key: &str) -> Vec<String>

Get all values for a key (systemd allows multiple entries with the same key)

pub fn set(&mut self, key: &str, value: &str)

Set a value for a key (replaces the first occurrence or adds if it doesn’t exist)

pub fn add(&mut self, key: &str, value: &str)

Add a value for a key (appends even if the key already exists)

pub fn insert_at(&mut self, index: usize, key: &str, value: &str)

Insert a value at a specific position (index is among entries only, not all nodes)

If the index is greater than or equal to the number of entries, the entry will be appended at the end.

Example

let input = r#"[Unit]
Description=Test Service
After=network.target
"#;
let unit = SystemdUnit::from_str(input).unwrap();
{
    let mut section = unit.get_section("Unit").unwrap();
    section.insert_at(1, "Wants", "foo.service");
}

let section = unit.get_section("Unit").unwrap();
let entries: Vec<_> = section.entries().collect();
assert_eq!(entries[0].key(), Some("Description".to_string()));
assert_eq!(entries[1].key(), Some("Wants".to_string()));
assert_eq!(entries[2].key(), Some("After".to_string()));

pub fn insert_before(&mut self, existing_key: &str, key: &str, value: &str)

Insert a value before the first entry with the specified key

If no entry with the specified key exists, this method does nothing.

Example

let input = r#"[Unit]
Description=Test Service
After=network.target
"#;
let unit = SystemdUnit::from_str(input).unwrap();
{
    let mut section = unit.get_section("Unit").unwrap();
    section.insert_before("After", "Wants", "foo.service");
}

let section = unit.get_section("Unit").unwrap();
let entries: Vec<_> = section.entries().collect();
assert_eq!(entries[0].key(), Some("Description".to_string()));
assert_eq!(entries[1].key(), Some("Wants".to_string()));
assert_eq!(entries[2].key(), Some("After".to_string()));

pub fn insert_after(&mut self, existing_key: &str, key: &str, value: &str)

Insert a value after the first entry with the specified key

If no entry with the specified key exists, this method does nothing.

Example

let input = r#"[Unit]
Description=Test Service
After=network.target
"#;
let unit = SystemdUnit::from_str(input).unwrap();
{
    let mut section = unit.get_section("Unit").unwrap();
    section.insert_after("Description", "Wants", "foo.service");
}

let section = unit.get_section("Unit").unwrap();
let entries: Vec<_> = section.entries().collect();
assert_eq!(entries[0].key(), Some("Description".to_string()));
assert_eq!(entries[1].key(), Some("Wants".to_string()));
assert_eq!(entries[2].key(), Some("After".to_string()));

pub fn set_list(&mut self, key: &str, values: &[&str])

Set a space-separated list value for a key

This is a convenience method for setting list-type directives (e.g., Wants=, After=). The values will be joined with spaces.

Example

section.set_list("Wants", &["foo.service", "bar.service"]);
// Results in: Wants=foo.service bar.service

pub fn get_list(&self, key: &str) -> Vec<String>

Get a value parsed as a space-separated list

This is a convenience method for getting list-type directives. If the key doesn’t exist, returns an empty vector.

pub fn get_bool(&self, key: &str) -> Option<bool>

Get a value parsed as a boolean

Returns None if the key doesn’t exist or if the value is not a valid boolean.

Example

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

pub fn set_bool(&mut self, key: &str, value: bool)

Set a boolean value for a key

This is a convenience method that formats the boolean as “yes” or “no”.

Example

let unit = SystemdUnit::from_str("[Service]\n").unwrap();
let mut section = unit.get_section("Service").unwrap();
section.set_bool("RemainAfterExit", true);
assert_eq!(section.get("RemainAfterExit"), Some("yes".to_string()));

pub fn remove(&mut self, key: &str)

Remove the first entry with the given key

pub fn remove_all(&mut self, key: &str)

Remove all entries with the given key

pub fn remove_value(&mut self, key: &str, value_to_remove: &str)

Remove a specific value from entries with the given key

This is useful for multi-value fields like After=, Wants=, etc. It handles space-separated values within a single entry and removes entire entries if they only contain the target value.

Example

let input = r#"[Unit]
After=network.target syslog.target
After=remote-fs.target
"#;
let unit = SystemdUnit::from_str(input).unwrap();
{
    let mut section = unit.sections().next().unwrap();
    section.remove_value("After", "syslog.target");
}

let section = unit.sections().next().unwrap();
let all_after = section.get_all("After");
assert_eq!(all_after.len(), 2);
assert_eq!(all_after[0], "network.target");
assert_eq!(all_after[1], "remote-fs.target");

pub fn remove_entries_where<F>(&mut self, predicate: F)

where F: FnMut(&str, &str) -> bool,

Remove entries matching a predicate

This provides a flexible way to remove entries based on arbitrary conditions. The predicate receives the entry’s key and value and should return true for entries that should be removed.

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 mut section = unit.sections().next().unwrap();
    section.remove_entries_where(|key, value| {
        key == "After" && value.split_whitespace().any(|v| v == "syslog.target")
    });
}

let section = unit.sections().next().unwrap();
let all_after = section.get_all("After");
assert_eq!(all_after.len(), 1);
assert_eq!(all_after[0], "remote-fs.target");
assert_eq!(section.get("Wants"), Some("foo.service".to_string()));

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 Section

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 Section

fn clone(&self) -> Section

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Section

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

Formats the value using the given formatter.

impl Hash for Section

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 Section

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

impl StructuralPartialEq for Section