Use this class a base of implementations of event handler to simplify the stack logic. More...

#include <event_handler_stack.hpp>

Public Types
using	state = HandlerState

using	pfn_relocate_arena = detail::pfn_relocate_arena

Public Member Functions
void	check_trailing_doc_token () const
	Check whether the current parse tokens are trailing on the previous doc, and raise an error if they are. More...

Public Attributes
detail::stack< state >	m_stack

state *	m_curr
	current stack level: top of the stack. cached here for easier access. More...

state *	m_parent
	parent of the current stack level. More...

pfn_relocate_arena	m_relocate_arena
	callback when the arena gets relocated More...

void *	m_relocate_arena_data

csubstr	m_src

Protected Member Functions
	EventHandlerStack ()

	EventHandlerStack (Callbacks const &cb)

void	_stack_start_parse (const char filename, csubstr ymlsrc, pfn_relocate_arena relocate_arena, void relocate_arena_data)

void	_stack_finish_parse ()

void	_stack_reset_root ()

void	_stack_reset_non_root ()

void	_stack_push ()

void	_stack_pop ()

bool	_stack_should_push_on_begin_doc () const

bool	_stack_should_pop_on_end_doc () const

void	_stack_relocate_to_new_arena (csubstr prev, substr curr)

substr	_stack_relocate_to_new_arena (csubstr s, csubstr prev, substr curr)

Detailed Description

template<class HandlerImpl, class HandlerState>
struct c4::yml::EventHandlerStack< HandlerImpl, HandlerState >

Use this class a base of implementations of event handler to simplify the stack logic.

Definition at line 41 of file event_handler_stack.hpp.

Member Typedef Documentation

◆ state

template<class HandlerImpl , class HandlerState >

using c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::state = HandlerState

Definition at line 46 of file event_handler_stack.hpp.

◆ pfn_relocate_arena

template<class HandlerImpl , class HandlerState >

using c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::pfn_relocate_arena = detail::pfn_relocate_arena

Definition at line 47 of file event_handler_stack.hpp.

Constructor & Destructor Documentation

◆ EventHandlerStack() [1/2]

template<class HandlerImpl , class HandlerState >

c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::EventHandlerStack ( )

inlineprotected

Definition at line 60 of file event_handler_stack.hpp.

60 : m_stack(), m_curr(), m_parent(), m_relocate_arena(), m_relocate_arena_data(), m_src() {}

c4::yml::EventHandlerStack::m_src

csubstr m_src

Definition: event_handler_stack.hpp:56

c4::yml::EventHandlerStack::m_curr

state * m_curr

current stack level: top of the stack. cached here for easier access.

Definition: event_handler_stack.hpp:52

c4::yml::EventHandlerStack::m_relocate_arena_data

void * m_relocate_arena_data

Definition: event_handler_stack.hpp:55

c4::yml::EventHandlerStack::m_relocate_arena

pfn_relocate_arena m_relocate_arena

callback when the arena gets relocated

Definition: event_handler_stack.hpp:54

c4::yml::EventHandlerStack::m_stack

detail::stack< state > m_stack

Definition: event_handler_stack.hpp:51

c4::yml::EventHandlerStack::m_parent

state * m_parent

parent of the current stack level.

Definition: event_handler_stack.hpp:53

◆ EventHandlerStack() [2/2]

template<class HandlerImpl , class HandlerState >

c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::EventHandlerStack ( Callbacks const & cb )

inlineprotected

Definition at line 61 of file event_handler_stack.hpp.

61 : m_stack(cb), m_curr(), m_parent(), m_relocate_arena(), m_relocate_arena_data(), m_src() {}

Member Function Documentation

◆ _stack_start_parse()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_start_parse	(	const char *	filename,
		csubstr	ymlsrc,
		pfn_relocate_arena	relocate_arena,
		void *	relocate_arena_data
	)

inlineprotected

Definition at line 65 of file event_handler_stack.hpp.

     {
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_curr != nullptr);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, relocate_arena != nullptr);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, relocate_arena_data != nullptr);
         m_curr->start_parse(filename, m_curr->node_id);
         m_relocate_arena = relocate_arena;
         m_relocate_arena_data = relocate_arena_data;
         m_src = ymlsrc;
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_relocate_arena, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_relocate_arena_data, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_src, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_finish_parse()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_finish_parse ( )

inlineprotected

Definition at line 76 of file event_handler_stack.hpp.

     {
         m_src = {};
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_src.

◆ _stack_reset_root()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_reset_root ( )

inlineprotected

Definition at line 83 of file event_handler_stack.hpp.

     {
         m_stack.clear();
         m_stack.push({});
         m_parent = nullptr;
         m_curr = &m_stack.top();
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_parent, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_reset_non_root()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_reset_non_root ( )

inlineprotected

Definition at line 91 of file event_handler_stack.hpp.

     {
         m_stack.clear();
         m_stack.push({}); // parent
         m_stack.push({}); // node
         m_parent = &m_stack.top(1);
         m_curr = &m_stack.top();
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_parent, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_push()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_push ( )

inlineprotected

Definition at line 100 of file event_handler_stack.hpp.

     {
         m_stack.push_top();
         m_parent = &m_stack.top(1); // don't use m_curr. watch out for relocations inside the prev push
         m_curr = &m_stack.top();
         m_curr->reset_after_push();
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_parent, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_pop()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_pop ( )

inlineprotected

Definition at line 108 of file event_handler_stack.hpp.

     {
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_parent);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_stack.size() > 1);
         m_parent->reset_before_pop(*m_curr);
         m_stack.pop();
         m_parent = m_stack.size() > 1 ? &m_stack.top(1) : nullptr;
         m_curr = &m_stack.top();
         #ifdef RYML_DBG
         if(m_parent)
             _c4dbgpf("popped! top is now node={} (parent={})", m_curr->node_id, m_parent->node_id);
         else
             _c4dbgpf("popped! top is now node={} @ ROOT", m_curr->node_id);
         #endif
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_parent, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_should_push_on_begin_doc()

template<class HandlerImpl , class HandlerState >

bool c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_should_push_on_begin_doc ( ) const

inlineprotected

Definition at line 129 of file event_handler_stack.hpp.

     {
         const bool is_root = (m_stack.size() == 1u);
         return is_root && (_has_any_(DOC|VAL|MAP|SEQ) || m_curr->has_children);
     }

References _has_any_, c4::yml::DOC, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack, c4::yml::MAP, c4::yml::SEQ, and c4::yml::VAL.

◆ _stack_should_pop_on_end_doc()

template<class HandlerImpl , class HandlerState >

bool c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_should_pop_on_end_doc ( ) const

inlineprotected

Definition at line 135 of file event_handler_stack.hpp.

     {
         const bool is_root = (m_stack.size() == 1u);
         return !is_root && _has_any_(DOC);
     }

References _has_any_, c4::yml::DOC, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_relocate_to_new_arena() [1/2]

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_relocate_to_new_arena	(	csubstr	prev,
		substr	curr
	)

inlineprotected

Definition at line 143 of file event_handler_stack.hpp.

     {
         for(state &st : m_stack)
         {
             if(st.line_contents.rem.is_sub(prev))
                 st.line_contents.rem = _stack_relocate_to_new_arena(st.line_contents.rem, prev, curr);
             if(st.line_contents.full.is_sub(prev))
                 st.line_contents.full = _stack_relocate_to_new_arena(st.line_contents.full, prev, curr);
         }
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_relocate_arena != nullptr);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_relocate_arena_data != nullptr);
         m_relocate_arena(m_relocate_arena_data, prev, curr);
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_relocate_arena, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_relocate_arena_data, and c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ _stack_relocate_to_new_arena() [2/2]

template<class HandlerImpl , class HandlerState >

substr c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::_stack_relocate_to_new_arena	(	csubstr	s,
		csubstr	prev,
		substr	curr
	)

inlineprotected

Definition at line 157 of file event_handler_stack.hpp.

     {
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, prev.is_super(s));
         auto pos = s.str - prev.str;
         substr out = {curr.str + pos, s.len};
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, curr.is_super(out));
         return out;
     }

References c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack.

◆ check_trailing_doc_token()

template<class HandlerImpl , class HandlerState >

void c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::check_trailing_doc_token ( ) const

inline

Check whether the current parse tokens are trailing on the previous doc, and raise an error if they are.

This function is called by the parse engine (not the event handler) before a doc is started.

Definition at line 172 of file event_handler_stack.hpp.

     {
         const bool is_root = (m_stack.size() == 1u);
         const bool isndoc = (m_curr->flags & NDOC) != 0;
         const bool suspicious = _has_any_(MAP|SEQ|VAL);
         _c4dbgpf("target={} isroot={} suspicious={} ndoc={}", m_curr->node_id, is_root, suspicious, isndoc);
         if((is_root || _has_any_(DOC)) && suspicious && !isndoc)
             _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "parse error");
     }

References _has_any_, c4::yml::DOC, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr, c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack, c4::yml::MAP, c4::yml::NDOC, c4::yml::SEQ, and c4::yml::VAL.

Member Data Documentation

◆ m_stack

template<class HandlerImpl , class HandlerState >

detail::stack<state> c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_stack

Definition at line 51 of file event_handler_stack.hpp.

◆ m_curr

template<class HandlerImpl , class HandlerState >

state* c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_curr

current stack level: top of the stack. cached here for easier access.

Definition at line 52 of file event_handler_stack.hpp.

◆ m_parent

template<class HandlerImpl , class HandlerState >

state* c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_parent

parent of the current stack level.

Definition at line 53 of file event_handler_stack.hpp.

◆ m_relocate_arena

template<class HandlerImpl , class HandlerState >

pfn_relocate_arena c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_relocate_arena

callback when the arena gets relocated

Definition at line 54 of file event_handler_stack.hpp.

◆ m_relocate_arena_data

template<class HandlerImpl , class HandlerState >

void* c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_relocate_arena_data

Definition at line 55 of file event_handler_stack.hpp.

◆ m_src

template<class HandlerImpl , class HandlerState >

csubstr c4::yml::EventHandlerStack< HandlerImpl, HandlerState >::m_src

Definition at line 56 of file event_handler_stack.hpp.

The documentation for this struct was generated from the following file:

/home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.11.1/src/c4/yml/event_handler_stack.hpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

template<class HandlerImpl, class HandlerState> struct c4::yml::EventHandlerStack< HandlerImpl, HandlerState >

Member Typedef Documentation

◆ state

◆ pfn_relocate_arena

Constructor & Destructor Documentation

◆ EventHandlerStack() [1/2]

◆ EventHandlerStack() [2/2]

Member Function Documentation

◆ _stack_start_parse()

◆ _stack_finish_parse()

◆ _stack_reset_root()

◆ _stack_reset_non_root()

◆ _stack_push()

◆ _stack_pop()

◆ _stack_should_push_on_begin_doc()

◆ _stack_should_pop_on_end_doc()

◆ _stack_relocate_to_new_arena() [1/2]

◆ _stack_relocate_to_new_arena() [2/2]

◆ check_trailing_doc_token()

Member Data Documentation

◆ m_stack

◆ m_curr

◆ m_parent

◆ m_relocate_arena

◆ m_relocate_arena_data

◆ m_src

template<class HandlerImpl, class HandlerState>
struct c4::yml::EventHandlerStack< HandlerImpl, HandlerState >