c4::yml::ParseEngine< EventHandler > Class Template Reference

This is the main driver of parsing logic: it scans the YAML or JSON source for tokens, and emits the appropriate sequence of parsing events to its event handler. More...

#include <parse_engine.hpp>

Public Types
using	handler_type = EventHandler

Public Member Functions
construction and assignment
	ParseEngine (EventHandler *evt_handler, ParserOptions opts={})
	~ParseEngine ()
	ParseEngine (ParseEngine &&)
	ParseEngine (ParseEngine const &)
ParseEngine &	operator= (ParseEngine &&)
ParseEngine &	operator= (ParseEngine const &)
modifiers
void	reserve_stack (id_type capacity)
	Reserve a certain capacity for the parsing stack. More...
void	reserve_locations (size_t num_source_lines)
	Reserve a certain capacity for the array used to track node locations in the source buffer. More...
void	reserve_filter_arena (size_t)
getters
ParserOptions const &	options () const
	Get the options used to build this parser object. More...
Callbacks const &	callbacks () const
	Get the current callbacks in the parser. More...
csubstr	filename () const
	Get the name of the latest file parsed by this object. More...
csubstr	source () const
	Get the latest YAML buffer parsed by this object. More...
id_type	stack_capacity () const
size_t	locations_capacity () const
size_t	filter_arena_capacity () const
parse methods
void	parse_in_place_ev (csubstr filename, substr src)
	parse YAML in place, emitting events to the current handler More...
void	parse_json_in_place_ev (csubstr filename, substr src)
	parse JSON in place, emitting events to the current handler More...
locations
Location	location (Tree const &tree, id_type node_id) const
	Get the location of a node of the last tree to be parsed by this parser. More...
Location	location (ConstNodeRef node) const
	Get the location of a node of the last tree to be parsed by this parser. More...
csubstr	location_contents (Location const &loc) const
	Get the string starting at a particular location, to the end of the parsed source buffer. More...
Location	val_location (const char *val) const
	Given a pointer to a buffer position, get the location. More...
scalar filtering
FilterResult	filter_scalar_plain (csubstr scalar, substr dst, size_t indentation)
	filter a plain scalar More...
FilterResult	filter_scalar_plain_in_place (substr scalar, size_t cap, size_t indentation)
	filter a plain scalar in place More...
FilterResult	filter_scalar_squoted (csubstr scalar, substr dst)
	filter a single-quoted scalar More...
FilterResult	filter_scalar_squoted_in_place (substr scalar, size_t cap)
	filter a single-quoted scalar in place More...
FilterResult	filter_scalar_dquoted (csubstr scalar, substr dst)
	filter a double-quoted scalar More...
FilterResultExtending	filter_scalar_dquoted_in_place (substr scalar, size_t cap)
	filter a double-quoted scalar in place More...
FilterResult	filter_scalar_block_literal (csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp)
	filter a block-literal scalar More...
FilterResult	filter_scalar_block_literal_in_place (substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp)
	filter a block-literal scalar in place More...
FilterResult	filter_scalar_block_folded (csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp)
	filter a block-folded scalar More...
FilterResult	filter_scalar_block_folded_in_place (substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp)
	filter a block-folded scalar in place More...

Detailed Description

template<class EventHandler>
class c4::yml::ParseEngine< EventHandler >

This is the main driver of parsing logic: it scans the YAML or JSON source for tokens, and emits the appropriate sequence of parsing events to its event handler.

The parse engine itself has no special limitations, and can accomodate containers as keys; it is the event handler may introduce additional constraints.

There are two implemented handlers (see Event Handlers, which has important notes about the event model):

• EventHandlerTree is the handler responsible for creating the ryml Tree
• EventHandlerYamlStd is the handler responsible for emitting standardized YAML test suite events, used (only) in the CI of this project. This is not part of the library and is not installed.

Definition at line 291 of file parse_engine.hpp.

Member Typedef Documentation

handler_type

template<class EventHandler >

using c4::yml::ParseEngine< EventHandler >::handler_type = EventHandler

Definition at line 295 of file parse_engine.hpp.

Constructor & Destructor Documentation

ParseEngine() [1/3]

template<class EventHandler >

c4::yml::ParseEngine< EventHandler >::ParseEngine	(	EventHandler *	evt_handler,
		ParserOptions	opts = {}
	)

Definition at line 233 of file parse_engine.def.hpp.

    : m_options(opts)
    , m_file()
    , m_buf()
    , m_evt_handler(evt_handler)
    , m_pending_anchors()
    , m_pending_tags()
    , m_newline_offsets()
    , m_newline_offsets_size(0)
    , m_newline_offsets_capacity(0)
    , m_newline_offsets_buf()
{
    RYML_CHECK(evt_handler);
}

~ParseEngine()

template<class EventHandler >

c4::yml::ParseEngine< EventHandler >::~ParseEngine

Definition at line 226 of file parse_engine.def.hpp.

{
    _free();
    _clr();
}

ParseEngine() [2/3]

template<class EventHandler >

c4::yml::ParseEngine< EventHandler >::ParseEngine

(

ParseEngine< EventHandler > &&

that

)

Definition at line 249 of file parse_engine.def.hpp.

    : m_options(that.m_options)
    , m_file(that.m_file)
    , m_buf(that.m_buf)
    , m_evt_handler(that.m_evt_handler)
    , m_pending_anchors(that.m_pending_anchors)
    , m_pending_tags(that.m_pending_tags)
    , m_newline_offsets(that.m_newline_offsets)
    , m_newline_offsets_size(that.m_newline_offsets_size)
    , m_newline_offsets_capacity(that.m_newline_offsets_capacity)
    , m_newline_offsets_buf(that.m_newline_offsets_buf)
{
    that._clr();
}

ParseEngine() [3/3]

template<class EventHandler >

c4::yml::ParseEngine< EventHandler >::ParseEngine

(

ParseEngine< EventHandler > const &

that

)

Definition at line 265 of file parse_engine.def.hpp.

    : m_options(that.m_options)
    , m_file(that.m_file)
    , m_buf(that.m_buf)
    , m_evt_handler(that.m_evt_handler)
    , m_pending_anchors(that.m_pending_anchors)
    , m_pending_tags(that.m_pending_tags)
    , m_newline_offsets()
    , m_newline_offsets_size()
    , m_newline_offsets_capacity()
    , m_newline_offsets_buf()
{
    if(that.m_newline_offsets_capacity)
    {
        _resize_locations(that.m_newline_offsets_capacity);
        _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_newline_offsets_capacity == that.m_newline_offsets_capacity);
        memcpy(m_newline_offsets, that.m_newline_offsets, that.m_newline_offsets_size * sizeof(size_t));
        m_newline_offsets_size = that.m_newline_offsets_size;
    }
}

Member Function Documentation

operator=() [1/2]

template<class EventHandler >

ParseEngine< EventHandler > & c4::yml::ParseEngine< EventHandler >::operator=

(

ParseEngine< EventHandler > &&

that

)

Definition at line 287 of file parse_engine.def.hpp.

{
    _free();
    m_options = (that.m_options);
    m_file = (that.m_file);
    m_buf = (that.m_buf);
    m_evt_handler = that.m_evt_handler;
    m_pending_anchors = that.m_pending_anchors;
    m_pending_tags = that.m_pending_tags;
    m_newline_offsets = (that.m_newline_offsets);
    m_newline_offsets_size = (that.m_newline_offsets_size);
    m_newline_offsets_capacity = (that.m_newline_offsets_capacity);
    m_newline_offsets_buf = (that.m_newline_offsets_buf);
    that._clr();
    return *this;
}

operator=() [2/2]

template<class EventHandler >

ParseEngine< EventHandler > & c4::yml::ParseEngine< EventHandler >::operator=

(

ParseEngine< EventHandler > const &

that

)

Definition at line 305 of file parse_engine.def.hpp.

{
    _free();
    m_options = (that.m_options);
    m_file = (that.m_file);
    m_buf = (that.m_buf);
    m_evt_handler = that.m_evt_handler;
    m_pending_anchors = that.m_pending_anchors;
    m_pending_tags = that.m_pending_tags;
    if(that.m_newline_offsets_capacity > m_newline_offsets_capacity)
        _resize_locations(that.m_newline_offsets_capacity);
    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_newline_offsets_capacity >= that.m_newline_offsets_capacity);
    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_newline_offsets_capacity >= that.m_newline_offsets_size);
    memcpy(m_newline_offsets, that.m_newline_offsets, that.m_newline_offsets_size * sizeof(size_t));
    m_newline_offsets_size = that.m_newline_offsets_size;
    m_newline_offsets_buf = that.m_newline_offsets_buf;
    return *this;
}

reserve_stack()

template<class EventHandler >

void c4::yml::ParseEngine< EventHandler >::reserve_stack ( id_type  capacity )

inline

Reserve a certain capacity for the parsing stack.

This should be larger than the expected depth of the parsed YAML tree.

The parsing stack is the only (potential) heap memory used directly by the parser.

If the requested capacity is below the default stack size of 16, the memory is used directly in the parser object; otherwise it will be allocated from the heap.

Note

this reserves memory only for the parser itself; all the allocations for the parsed tree will go through the tree's allocator (when different).

for maximum efficiency, the tree and the arena can (and should) also be reserved.

Definition at line 334 of file parse_engine.hpp.

    {
        m_evt_handler->m_stack.reserve(capacity);
    }

Referenced by sample::sample_global_allocator(), sample::sample_parse_reuse_parser(), and sample::sample_parse_reuse_tree_and_parser().

reserve_locations()

template<class EventHandler >

void c4::yml::ParseEngine< EventHandler >::reserve_locations ( size_t  num_source_lines )

inline

Reserve a certain capacity for the array used to track node locations in the source buffer.

Definition at line 341 of file parse_engine.hpp.

    {
        _resize_locations(num_source_lines);
    }

Referenced by sample::sample_location_tracking().

reserve_filter_arena()

template<class EventHandler >

void c4::yml::ParseEngine< EventHandler >::reserve_filter_arena ( size_t  )

inline

Definition at line 347 of file parse_engine.hpp.

{}

options()

template<class EventHandler >

ParserOptions const& c4::yml::ParseEngine< EventHandler >::options ( ) const

inline

Get the options used to build this parser object.

Definition at line 357 of file parse_engine.hpp.

{ return m_options; }

Referenced by sample::sample_location_tracking().

callbacks()

template<class EventHandler >

Callbacks const& c4::yml::ParseEngine< EventHandler >::callbacks ( ) const

inline

Get the current callbacks in the parser.

Definition at line 360 of file parse_engine.hpp.

{ RYML_ASSERT(m_evt_handler); return m_evt_handler->m_stack.m_callbacks; }

Referenced by c4::yml::parse_in_arena(), c4::yml::parse_in_place(), c4::yml::parse_json_in_arena(), and c4::yml::parse_json_in_place().

filename()

template<class EventHandler >

csubstr c4::yml::ParseEngine< EventHandler >::filename ( ) const

inline

Get the name of the latest file parsed by this object.

Definition at line 363 of file parse_engine.hpp.

{ return m_file; }

source()

template<class EventHandler >

csubstr c4::yml::ParseEngine< EventHandler >::source ( ) const

inline

Get the latest YAML buffer parsed by this object.

Definition at line 366 of file parse_engine.hpp.

{ return m_buf; }

stack_capacity()

template<class EventHandler >

id_type c4::yml::ParseEngine< EventHandler >::stack_capacity ( ) const

inline

Definition at line 368 of file parse_engine.hpp.

{ RYML_ASSERT(m_evt_handler); return m_evt_handler->m_stack.capacity(); }

locations_capacity()

template<class EventHandler >

size_t c4::yml::ParseEngine< EventHandler >::locations_capacity ( ) const

inline

Definition at line 369 of file parse_engine.hpp.

{ return m_newline_offsets_capacity; }

filter_arena_capacity()

template<class EventHandler >

size_t c4::yml::ParseEngine< EventHandler >::filter_arena_capacity ( ) const

inline

Definition at line 372 of file parse_engine.hpp.

{ return 0u; }

parse_in_place_ev()

template<class EventHandler >

void c4::yml::ParseEngine< EventHandler >::parse_in_place_ev	(	csubstr	filename,
		substr	src
	)

parse YAML in place, emitting events to the current handler

Definition at line 8046 of file parse_engine.def.hpp.

{
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_stack.size() >= 1);
    m_file = filename;
    m_buf = src;
    _reset();
    m_evt_handler->start_parse(filename.str, &_s_relocate_arena, this);
    m_evt_handler->begin_stream();
    while( ! _finished_file())
    {
        _scan_line();
        while( ! _finished_line())
        {
            _c4dbgnextline();
            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! m_evt_handler->m_curr->line_contents.rem.empty());
            if(has_any(FLOW))
            {
                if(has_none(RSEQIMAP))
                {
                    if(has_any(RSEQ))
                    {
                        _handle_seq_flow();
                    }
                    else
                    {
                        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
                        _handle_map_flow();
                    }
                }
                else
                {
                    _handle_seq_imap();
                }
            }
            else if(has_any(BLCK))
            {
                if(has_any(RSEQ))
                {
                    _handle_seq_block();
                }
                else
                {
                    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
                    _handle_map_block();
                }
            }
            else if(has_any(RUNK))
            {
                _handle_unk();
            }
            else if(has_any(USTY))
            {
                _handle_usty();
            }
            else
            {
                _c4err("internal error");
            }
        }
        if(_finished_file())
            break; // it may have finished because of multiline blocks
        _line_ended();
    }
    _end_stream();
    m_evt_handler->finish_parse();
}

References _c4dbgnextline, c4::yml::BLCK, c4::yml::FLOW, c4::yml::RMAP, c4::yml::RSEQ, c4::yml::RSEQIMAP, c4::yml::RUNK, and c4::yml::USTY.

Referenced by c4::yml::parse_in_place().

parse_json_in_place_ev()

template<class EventHandler >

void c4::yml::ParseEngine< EventHandler >::parse_json_in_place_ev	(	csubstr	filename,
		substr	src
	)

parse JSON in place, emitting events to the current handler

Definition at line 8002 of file parse_engine.def.hpp.

{
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_stack.size() >= 1);
    m_file = filename;
    m_buf = src;
    _reset();
    m_evt_handler->start_parse(filename.str, &_s_relocate_arena, this);
    m_evt_handler->begin_stream();
    while( ! _finished_file())
    {
        _scan_line();
        while( ! _finished_line())
        {
            _c4dbgnextline();
            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! m_evt_handler->m_curr->line_contents.rem.empty());
            if(has_any(RSEQ))
            {
                _handle_seq_json();
            }
            else if(has_any(RMAP))
            {
                _handle_map_json();
            }
            else if(has_any(RUNK))
            {
                _handle_unk_json();
            }
            else
            {
                _c4err("internal error");
            }
        }
        if(_finished_file())
            break; // it may have finished because of multiline blocks
        _line_ended();
    }
    _end_stream();
    m_evt_handler->finish_parse();
}

References _c4dbgnextline, c4::yml::RMAP, c4::yml::RSEQ, and c4::yml::RUNK.

Referenced by c4::yml::parse_json_in_place().

location() [1/2]

template<class EventHandler >

Location c4::yml::ParseEngine< EventHandler >::location	(	Tree const &	tree,
		id_type	node_id
	)		const

Get the location of a node of the last tree to be parsed by this parser.

Definition at line 3824 of file parse_engine.def.hpp.

{
    // try hard to avoid getting the location from a null string.
    Location loc;
    if(_location_from_node(tree, node, &loc, 0))
        return loc;
    return val_location(m_buf.str);
}

Referenced by sample::sample_location_tracking(), and sample::sample_quick_overview().

location() [2/2]

template<class EventHandler >

Location c4::yml::ParseEngine< EventHandler >::location

(

ConstNodeRef

node

)

const

Get the location of a node of the last tree to be parsed by this parser.

Definition at line 3817 of file parse_engine.def.hpp.

{
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, node.readable());
    return location(*node.tree(), node.id());
}

References c4::yml::ConstNodeRef::id(), c4::yml::ConstNodeRef::readable(), and c4::yml::ConstNodeRef::tree().

location_contents()

template<class EventHandler >

csubstr c4::yml::ParseEngine< EventHandler >::location_contents

(

Location const &

loc

)

const

Get the string starting at a particular location, to the end of the parsed source buffer.

Definition at line 3810 of file parse_engine.def.hpp.

{
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, loc.offset < m_buf.len);
    return m_buf.sub(loc.offset);
}

References c4::yml::Location::offset.

Referenced by sample::sample_location_tracking(), and sample::sample_quick_overview().

val_location()

template<class EventHandler >

Location c4::yml::ParseEngine< EventHandler >::val_location

(

const char *

val

)

const

Given a pointer to a buffer position, get the location.

Parameters

[in]

val

must be pointing to somewhere in the source buffer that was last parsed by this object.

Definition at line 3930 of file parse_engine.def.hpp.

{
    if(C4_UNLIKELY(val == nullptr))
        return {m_file, 0, 0, 0};
    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_options.locations());
    // NOTE: if any of these checks fails, the parser needs to be
    // instantiated with locations enabled.
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.str == m_newline_offsets_buf.str);
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.len == m_newline_offsets_buf.len);
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_options.locations());
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !_locations_dirty());
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_newline_offsets != nullptr);
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_newline_offsets_size > 0);
    // NOTE: the pointer needs to belong to the buffer that was used to parse.
    csubstr src = m_buf;
    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, val != nullptr || src.str == nullptr);
    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, (val >= src.begin() && val <= src.end()) || (src.str == nullptr && val == nullptr));
    // ok. search the first stored newline after the given ptr
    using lineptr_type = size_t const* C4_RESTRICT;
    lineptr_type lineptr = nullptr;
    size_t offset = (size_t)(val - src.begin());
    if(m_newline_offsets_size < RYML_LOCATIONS_SMALL_THRESHOLD)
    {
        // just do a linear search if the size is small.
        for(lineptr_type curr = m_newline_offsets, last = m_newline_offsets + m_newline_offsets_size; curr < last; ++curr)
        {
            if(*curr > offset)
            {
                lineptr = curr;
                break;
            }
        }
    }
    else
    {
        // do a bisection search if the size is not small.
        //
        // We could use std::lower_bound but this is simple enough and
        // spares the costly include of <algorithm>.
        size_t count = m_newline_offsets_size;
        size_t step;
        lineptr_type it;
        lineptr = m_newline_offsets;
        while(count)
        {
            step = count >> 1;
            it = lineptr + step;
            if(*it < offset)
            {
                lineptr = ++it;
                count -= step + 1;
            }
            else
            {
                count = step;
            }
        }
    }
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, lineptr >= m_newline_offsets);
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, lineptr <= m_newline_offsets + m_newline_offsets_size);
    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, *lineptr > offset);
    Location loc;
    loc.name = m_file;
    loc.offset = offset;
    loc.line = (size_t)(lineptr - m_newline_offsets);
    if(lineptr > m_newline_offsets)
        loc.col = (offset - *(lineptr-1) - 1u);
    else
        loc.col = offset;
    return loc;
}

References c4::yml::Location::col, c4::yml::Location::line, c4::yml::Location::name, c4::yml::Location::offset, and RYML_LOCATIONS_SMALL_THRESHOLD.

filter_scalar_plain()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_plain	(	csubstr	scalar,
		substr	dst,
		size_t	indentation
	)

filter a plain scalar

Definition at line 2358 of file parse_engine.def.hpp.

{
    FilterProcessorSrcDst proc(scalar, dst);
    return _filter_plain(proc, indentation);
}

filter_scalar_plain_in_place()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_plain_in_place	(	substr	scalar,
		size_t	cap,
		size_t	indentation
	)

filter a plain scalar in place

Definition at line 2365 of file parse_engine.def.hpp.

{
    FilterProcessorInplaceEndExtending proc(dst, cap);
    return _filter_plain(proc, indentation);
}

filter_scalar_squoted()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_squoted	(	csubstr	scalar,
		substr	dst
	)

filter a single-quoted scalar

Definition at line 2469 of file parse_engine.def.hpp.

{
    FilterProcessorSrcDst proc(scalar, dst);
    return _filter_squoted(proc);
}

filter_scalar_squoted_in_place()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_squoted_in_place	(	substr	scalar,
		size_t	cap
	)

filter a single-quoted scalar in place

Definition at line 2476 of file parse_engine.def.hpp.

{
    FilterProcessorInplaceEndExtending proc(dst, cap);
    return _filter_squoted(proc);
}

filter_scalar_dquoted()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_dquoted	(	csubstr	scalar,
		substr	dst
	)

filter a double-quoted scalar

Definition at line 2760 of file parse_engine.def.hpp.

{
    FilterProcessorSrcDst proc(scalar, dst);
    return _filter_dquoted(proc);
}

filter_scalar_dquoted_in_place()

template<class EventHandler >

FilterResultExtending c4::yml::ParseEngine< EventHandler >::filter_scalar_dquoted_in_place	(	substr	scalar,
		size_t	cap
	)

filter a double-quoted scalar in place

Definition at line 2767 of file parse_engine.def.hpp.

{
    FilterProcessorInplaceMidExtending proc(dst, cap);
    return _filter_dquoted(proc);
}

filter_scalar_block_literal()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_block_literal	(	csubstr	scalar,
		substr	dst,
		size_t	indentation,
		BlockChomp_e	chomp
	)

filter a block-literal scalar

Definition at line 3091 of file parse_engine.def.hpp.

{
    FilterProcessorSrcDst proc(scalar, dst);
    return _filter_block_literal(proc, indentation, chomp);
}

filter_scalar_block_literal_in_place()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_block_literal_in_place	(	substr	scalar,
		size_t	cap,
		size_t	indentation,
		BlockChomp_e	chomp
	)

filter a block-literal scalar in place

Definition at line 3098 of file parse_engine.def.hpp.

{
    FilterProcessorInplaceEndExtending proc(scalar, cap);
    return _filter_block_literal(proc, indentation, chomp);
}

filter_scalar_block_folded()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_block_folded	(	csubstr	scalar,
		substr	dst,
		size_t	indentation,
		BlockChomp_e	chomp
	)

filter a block-folded scalar

Definition at line 3377 of file parse_engine.def.hpp.

{
    FilterProcessorSrcDst proc(scalar, dst);
    return _filter_block_folded(proc, indentation, chomp);
}

filter_scalar_block_folded_in_place()

template<class EventHandler >

FilterResult c4::yml::ParseEngine< EventHandler >::filter_scalar_block_folded_in_place	(	substr	scalar,
		size_t	cap,
		size_t	indentation,
		BlockChomp_e	chomp
	)

filter a block-folded scalar in place

Definition at line 3384 of file parse_engine.def.hpp.

{
    FilterProcessorInplaceEndExtending proc(scalar, cap);
    return _filter_block_folded(proc, indentation, chomp);
}

---

The documentation for this class was generated from the following files:

• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.7.0/src/c4/yml/fwd.hpp
• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.7.0/src/c4/yml/parse_engine.hpp
• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.7.0/src/c4/yml/parse_engine.def.hpp