Struct kdl::KdlNode

pub struct KdlNode { /* private fields */ }

Represents an individual KDL Node inside a KDL Document.

Implementations

impl KdlNode

pub fn new(name: impl Into<KdlIdentifier>) -> Self

Creates a new KdlNode with a given name.

pub fn name(&self) -> &KdlIdentifier

Gets this node’s name.

pub fn name_mut(&mut self) -> &mut KdlIdentifier

Gets a mutable reference to this node’s name.

pub fn set_name(&mut self, name: impl Into<KdlIdentifier>)

Sets this node’s name.

pub fn span(&self) -> &SourceSpan

Gets this node’s span.

This value will be properly initialized when created via [KdlDocument::parse] but may become invalidated if the document is mutated. We do not currently guarantee this to yield any particularly consistent results at that point.

pub fn span_mut(&mut self) -> &mut SourceSpan

Gets a mutable reference to this node’s span.

pub fn set_span(&mut self, span: impl Into<SourceSpan>)

Sets this node’s span.

pub fn ty(&self) -> Option<&KdlIdentifier>

Gets the node’s type identifier, if any.

pub fn ty_mut(&mut self) -> &mut Option<KdlIdentifier>

Gets a mutable reference to the node’s type identifier.

pub fn set_ty(&mut self, ty: impl Into<KdlIdentifier>)

Sets the node’s type identifier.

pub fn entries(&self) -> &[KdlEntry]

Returns a reference to this node’s entries (arguments and properties).

pub fn entries_mut(&mut self) -> &mut Vec<KdlEntry>

Returns a mutable reference to this node’s entries (arguments and properties).

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

Gets leading text (whitespace, comments) for this node.

pub fn set_leading(&mut self, leading: impl Into<String>)

Sets leading text (whitespace, comments) for this node.

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

Gets text (whitespace, comments) right before the children block’s starting {.

pub fn set_before_children(&mut self, before: impl Into<String>)

Gets text (whitespace, comments) right before the children block’s starting {.

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

Gets trailing text (whitespace, comments) for this node.

pub fn set_trailing(&mut self, trailing: impl Into<String>)

Sets trailing text (whitespace, comments) for this node.

pub fn len(&self) -> usize

Length of this node when rendered as a string.

pub fn is_empty(&self) -> bool

Returns true if this node is completely empty (including whitespace).

pub fn clear_fmt(&mut self)

Clears leading and trailing text (whitespace, comments), as well as the space before the children block, if any. Individual entries and their formatting will be preserved.

If you want to clear formatting on all children and entries as well, use Self::clear_fmt_recursive.

pub fn clear_fmt_recursive(&mut self)

Clears leading and trailing text (whitespace, comments), as well as the space before the children block, if any. Individual entries and children formatting will also be cleared.

pub fn get(&self, key: impl Into<NodeKey>) -> Option<&KdlEntry>

Fetches an entry by key. Number keys will look up arguments, strings will look up properties.

pub fn get_mut(&mut self, key: impl Into<NodeKey>) -> Option<&mut KdlEntry>

Fetches a mutable referene to an entry by key. Number keys will look up arguments, strings will look up properties.

pub fn insert(
    &mut self,
    key: impl Into<NodeKey>,
    entry: impl Into<KdlEntry>
) -> Option<KdlEntry>

Inserts an entry into this node. If an entry already exists with the same key, it will be replaced and the previous entry will be returned.

Numerical keys will insert arguments, string keys will insert properties.

pub fn remove(&mut self, key: impl Into<NodeKey>) -> Option<KdlEntry>

Removes an entry from this node. If an entry already exists with the same key, it will be returned.

Numerical keys will remove arguments, string keys will remove properties.

pub fn push(&mut self, entry: impl Into<KdlEntry>)

Shorthand for self.entries_mut().push(entry).

pub fn clear_entries(&mut self)

Shorthand for self.entries_mut().clear()

pub fn children(&self) -> Option<&KdlDocument>

Returns a reference to this node’s children, if any.

pub fn children_mut(&mut self) -> &mut Option<KdlDocument>

Returns a mutable reference to this node’s children, if any.

pub fn set_children(&mut self, children: KdlDocument)

Sets the KdlDocument representing this node’s children.

pub fn clear_children(&mut self)

Removes this node’s children completely.

pub fn ensure_children(&mut self) -> &mut KdlDocument

Returns a mutable reference to this node’s children KdlDocument, creating one first if one does not already exist.

pub fn fmt(&mut self)

Auto-formats this node and its contents.

pub fn fmt_no_comments(&mut self)

Auto-formats this node and its contents, stripping comments.

Trait Implementations

impl Clone for KdlNode

fn clone(&self) -> KdlNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KdlNode

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

Formats the value using the given formatter.

impl Display for KdlNode

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

Formats the value using the given formatter.

impl FromStr for KdlNode

type Err = KdlError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Index<&str> for KdlNode

type Output = KdlValue

The returned type after indexing.

fn index(&self, key: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for KdlNode

type Output = KdlValue

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<&str> for KdlNode

fn index_mut(&mut self, key: &str) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<usize> for KdlNode

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq<KdlNode> for KdlNode

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

This method tests for self and other values to be equal, and is used by ==.

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

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