Struct IcalLine 

pub struct IcalLine<'a> {
    pub name: IcalLeaf<'a>,
    pub params: Vec<IcalParamNode<'a>>,
    pub value: IcalValueNode<'a>,
    pub eol: IcalLeaf<'a>,
    pub wire: IcalWire<'a>,
}

Available on crate feature parser only.

One raw content line: a name, parameters, a value and the line ending.

This is a logical line: take unfolds RFC 5545 3.1 continuations and QUOTED-PRINTABLE soft breaks, so a line holds no internal break, only its terminating eol, and what it unfolded is kept on wire to put the folds back on output.

It is also the syntactic unit for the BEGIN / VERSION / END envelope lines, not only decoded properties.

Fields

name: IcalLeaf<'a>

The property name leaf, with any group prefix.

params: Vec<IcalParamNode<'a>>

The parameters, in source order.

value: IcalValueNode<'a>

The value.

eol: IcalLeaf<'a>

The line ending (\r\n or \n).

wire: IcalWire<'a>

How the line was laid out on the wire: its folds, the blank lines before it, its soft breaks. Empty for a built line, and dropped on output once an edit changes the line’s length (see IcalWire).

Implementations

impl IcalLine<'_>

pub fn decode(&self, version: IcalVersion) -> IcalProp<'_>

Decode the line into a typed property. A known property dispatches its value through the spec (see decode_value); an unknown one keeps its raw components so it round-trips.

impl<'a> IcalLine<'a>

pub fn text( name: impl Into<Cow<'a, str>>, value: impl Into<Cow<'a, str>>, ) -> Self

Build a property line with a raw text value and the default \r\n ending. Used to seed BEGIN/VERSION/END and to encode simple values.

pub fn take(rest: &'a [u8]) -> Result<(Self, &'a [u8]), IcalParseError>

Tokenise the logical line at the start of rest, unfolding as it goes.

Returns the line and the remaining input. RFC 5545 3.1 folds a long line by inserting a CRLF and a single leading space or tab; unfolding drops them. A line with no folds borrows the source; a folded one is rebuilt owned, its bytes no longer contiguous.

pub fn take_physical(rest: &'a [u8]) -> (&'a [u8], &'a [u8])

Split the first physical line off rest verbatim, content and ending.

Returned with what follows. This is the recovering parser’s step over a line take refuses: the bytes are kept whole rather than structured, so they still round-trip.

pub fn raw_value(&self) -> &[u8]

The raw bytes of the line’s first value, for simple single-value lines.

pub fn raw_value_str(&self) -> Cow<'_, str>

The raw first value as UTF-8 text, lossily; for the ASCII envelope values (VERSION) and diagnostics.

pub fn param<P: IcalParamLens>(&self) -> Option<P::Target<'_>>

The first parameter of type P, decoded.

pub fn param_mut<P: IcalParamLens>(&mut self) -> Option<&mut IcalParamNode<'a>>

The first parameter of type P, mutably (raw, for editing its leaves).

Trait Implementations

impl<'a> Clone for IcalLine<'a>

fn clone(&self) -> IcalLine<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for IcalLine<'a>

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

Formats the value using the given formatter.

impl Display for IcalLine<'_>

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

The line as text, wire shape included, lossily for a non-UTF-8 value. IcalLine::write_bytes is the byte-faithful path.