Enum VTEvent 

pub enum VTEvent<'a> {
    Raw(&'a [u8]),
    C0(u8),
    Esc(Esc),
    EscInvalid(EscInvalid),
    Ss2(SS2),
    Ss3(SS3),
    Csi(CSI<'a>),
    DcsStart(DCS<'a>),
    DcsData(&'a [u8]),
    DcsEnd(&'a [u8]),
    DcsCancel,
    OscStart,
    OscData(&'a [u8]),
    OscEnd {
        data: &'a [u8],
        used_bel: bool,
    },
    OscCancel,
}

A union of all possible events that can be emitted by the parser, with borrowed data.

Variants

Raw(&'a [u8])

C0(u8)

Esc(Esc)

EscInvalid(EscInvalid)

Ss2(SS2)

Ss3(SS3)

Csi(CSI<'a>)

DcsStart(DCS<'a>)

DcsData(&'a [u8])

DcsEnd(&'a [u8])

DcsCancel

OscStart

OscData(&'a [u8])

OscEnd

Fields

data: &'a [u8]

used_bel: bool

Whether the BEL was used to end the OSC stream.

OscCancel

Implementations

impl<'a> VTEvent<'a>

pub fn csi(&self) -> Option<CSI<'a>>

pub fn byte_len(&self) -> usize

pub fn encode(&self, buf: &mut [u8]) -> Result<usize, usize>

Encode the event into the provided buffer, returning the number of bytes required for the escape sequence in either Ok(n) or Err(n).

Note that some events may have multiple possible encodings, so this method may decide to choose whichever is more efficient.

pub fn write_to(&self, writer: impl Write) -> Result<usize, Error>

Encode the event into the provided writer, returning the number of bytes written.

If the write fails for any reason, it is not possible to determine how many bytes were written.

The order of writes is not specified and may change between versions of this crate.

pub fn to_owned(&self) -> VTOwnedEvent

Trait Implementations

impl<'a> Clone for VTEvent<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for VTEvent<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for VTEvent<'a>

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<'a> PartialEq for VTEvent<'a>

fn eq(&self, other: &VTEvent<'a>) -> 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<'a> Eq for VTEvent<'a>

impl<'a> StructuralPartialEq for VTEvent<'a>