Struct StreamingParser 

pub struct StreamingParser<'a> {

    scanner: Option<BasicScanner>,
    zero_scanner: Option<ZeroScanner<'a>>,
    config: StreamingConfig,
    event_buffer: VecDeque<Event>,
    state: ParserState,
    state_stack: Vec<ParserState>,
    position: Position,
    depth: usize,
    pending_anchor: Option<String>,
    pending_tag: Option<String>,
    stats: Option<StreamingStats>,
    start_time: Instant,
    stream_ended: bool,
}

Streaming YAML parser that processes events on demand

Fields

scanner: Option<BasicScanner>

Traditional scanner for compatibility

zero_scanner: Option<ZeroScanner<'a>>

Zero-copy scanner for optimized parsing

config: StreamingConfig

Configuration

event_buffer: VecDeque<Event>

Event buffer for batched processing

state: ParserState

Current parser state

state_stack: Vec<ParserState>

State stack for nested structures

position: Position

Current position

depth: usize

Current nesting depth

pending_anchor: Option<String>

Pending anchor for next node

pending_tag: Option<String>

Pending tag for next node

stats: Option<StreamingStats>

Statistics (if enabled)

start_time: Instant

Start time for performance measurement

stream_ended: bool

Whether the stream has ended

Implementations

impl<'a> StreamingParser<'a>

pub fn new(input: String, config: StreamingConfig) -> StreamingParser<'static>

Create a new streaming parser with traditional scanner

pub fn new_zero_copy(input: &'a str, config: StreamingConfig) -> Self

Create a new streaming parser with zero-copy scanner

pub fn next_batch(&mut self) -> Result<Vec<Event>>

Get the next batch of events

fn next_event_internal(&mut self) -> Result<Option<Event>>

Get the next event from buffer or generate a new one

fn generate_events(&mut self) -> Result<()>

Generate events by processing tokens

fn generate_events_zero_copy(&mut self) -> Result<()>

Generate events using zero-copy scanner

fn generate_events_traditional(&mut self) -> Result<()>

Generate events using traditional scanner

fn is_document_start_candidate_simple(&self) -> bool

Check if this position could be document start (—) - simplified version

fn is_document_end_candidate_simple(&self) -> bool

Check if this position could be document end (…) - simplified version

fn is_value_indicator_simple(&self) -> bool

Check if colon is a value indicator - simplified version

fn handle_document_start(&mut self)

Handle document start

fn handle_document_end(&mut self)

Handle document end

fn handle_flow_sequence_start(&mut self)

Handle flow sequence start

fn handle_flow_sequence_end(&mut self)

Handle flow sequence end

fn handle_flow_mapping_start(&mut self)

Handle flow mapping start

fn handle_flow_mapping_end(&mut self)

Handle flow mapping end

fn handle_value_indicator(&mut self)

Handle value indicator (:)

fn handle_zero_copy_scalar(&mut self, token: ZeroToken<'_>) -> Result<()>

Handle zero-copy scalar token

fn skip_comment_simple(&mut self)

Skip comment line - simplified version

fn process_token(&mut self, token: Token) -> Result<()>

Process a token from traditional scanner

fn push_state(&mut self, new_state: ParserState)

Push a new state onto the stack

fn pop_state(&mut self)

Pop state from the stack

fn update_stats_for_event(&mut self, _event: &Event)

Update statistics for processed event

pub fn get_stats(&mut self) -> Option<StreamingStats>

Get current parsing statistics

pub fn has_more_events(&self) -> bool

Check if more events are available

pub fn buffer_size(&self) -> usize

Get the current buffer size

Trait Implementations

impl<'a> Parser for StreamingParser<'a>

fn check_event(&self) -> bool

Check if there are more events available

fn peek_event(&self) -> Result<Option<&Event>>

Peek at the next event without consuming it

fn get_event(&mut self) -> Result<Option<Event>>

Get the next event, consuming it

fn reset(&mut self)

Reset the parser state

fn position(&self) -> Position

Get the current position in the input