Filters in place. More...

#include <filter_processor.hpp>

Public Member Functions
	FilterProcessorInplaceMidExtending (substr src_, size_t wcap_) noexcept

void	setwpos (size_t wpos_) noexcept

void	setpos (size_t rpos_, size_t wpos_) noexcept

void	set_at_end () noexcept

bool	has_more_chars () const noexcept

bool	has_more_chars (size_t maxpos) const noexcept

FilterResultExtending	result () const noexcept

csubstr	sofar () const noexcept

csubstr	rem () const noexcept

char	curr () const noexcept

char	next () const noexcept

void	skip () noexcept

void	skip (size_t num) noexcept

void	set_at (size_t pos, char c) noexcept

void	set (char c) noexcept

void	set (char c, size_t num) noexcept

void	copy () noexcept

void	copy (size_t num) noexcept

void	translate_esc (char c) noexcept

void	translate_esc_bulk (const char *s, size_t nw, size_t nr) noexcept

void	translate_esc_extending (const char *s, size_t nw, size_t nr) noexcept

Public Attributes
substr	src
	the subject string More...

size_t	wcap
	write capacity - the capacity of the subject string's buffer More...

size_t	rpos
	read position More...

size_t	wpos
	write position More...

size_t	maxcap
	the max capacity needed for filtering the string. This may be larger than the final string size. More...

bool	unfiltered_chars
	number of characters that were not added to wpos from lack of capacity More...

Detailed Description

Filters in place.

The result may be larger than the source, and extending may happen anywhere. As a result some characters may be left unfiltered when there is no slack in the buffer and the write-position would overlap the read-position. Consequently, it's possible for characters to be left unfiltered. In YAML, this happens only with double-quoted strings, and only with a small number of escape sequences such as \L which is substituted by three bytes. These escape sequences cause a call to translate_esc_extending() which is the only entry point to this unfiltered situation.

See also: FilterProcessorInplaceMidExtending

Definition at line 307 of file filter_processor.hpp.

Constructor & Destructor Documentation

◆ FilterProcessorInplaceMidExtending()

c4::yml::FilterProcessorInplaceMidExtending::FilterProcessorInplaceMidExtending	(	substr	src_,
		size_t	wcap_
	)

inlinenoexcept

Definition at line 316 of file filter_processor.hpp.

         : src(src_)
         , wcap(wcap_)
         , rpos(0)
         , wpos(0)
         , maxcap(src.len)
         , unfiltered_chars(false)
     {
         _RYML_ASSERT_BASIC(wcap >= src.len);
     }

References src, and wcap.

Member Function Documentation

◆ setwpos()

void c4::yml::FilterProcessorInplaceMidExtending::setwpos ( size_t wpos_ )

inlinenoexcept

Definition at line 327 of file filter_processor.hpp.

327 { wpos = wpos_; }

References wpos.

◆ setpos()

void c4::yml::FilterProcessorInplaceMidExtending::setpos	(	size_t	rpos_,
		size_t	wpos_
	)

inlinenoexcept

Definition at line 328 of file filter_processor.hpp.

328 { rpos = rpos_; wpos = wpos_; }

References rpos, and wpos.

◆ set_at_end()

void c4::yml::FilterProcessorInplaceMidExtending::set_at_end ( )

inlinenoexcept

Definition at line 329 of file filter_processor.hpp.

329 { skip(src.len - rpos); }

c4::yml::FilterProcessorInplaceMidExtending::skip

void skip() noexcept

Definition: filter_processor.hpp:349

References rpos, skip(), and src.

◆ has_more_chars() [1/2]

bool c4::yml::FilterProcessorInplaceMidExtending::has_more_chars ( ) const

inlinenoexcept

Definition at line 331 of file filter_processor.hpp.

331 { return rpos < src.len; }

References rpos, and src.

◆ has_more_chars() [2/2]

bool c4::yml::FilterProcessorInplaceMidExtending::has_more_chars ( size_t maxpos ) const

inlinenoexcept

Definition at line 332 of file filter_processor.hpp.

332 { _RYML_ASSERT_BASIC(maxpos <= src.len); return rpos < maxpos; }

References rpos, and src.

◆ result()

FilterResultExtending c4::yml::FilterProcessorInplaceMidExtending::result ( ) const

inlinenoexcept

Definition at line 334 of file filter_processor.hpp.

     {
         _c4dbgip("inplace: wpos={} wcap={} unfiltered={} maxcap={}", this->wpos, this->wcap, this->unfiltered_chars, this->maxcap);
         FilterResultExtending ret;
         ret.str.str = (wpos <= wcap && !unfiltered_chars) ? src.str : nullptr;
         ret.str.len = wpos;
         ret.reqlen = maxcap;
         return ret;
     }

References maxcap, c4::yml::FilterResultExtending::reqlen, src, c4::yml::FilterResultExtending::str, unfiltered_chars, wcap, and wpos.

◆ sofar()

csubstr c4::yml::FilterProcessorInplaceMidExtending::sofar ( ) const

inlinenoexcept

Definition at line 343 of file filter_processor.hpp.

343 { return csubstr(src.str, wpos <= wcap ? wpos : wcap); }

References src, wcap, and wpos.

◆ rem()

csubstr c4::yml::FilterProcessorInplaceMidExtending::rem ( ) const

inlinenoexcept

Definition at line 344 of file filter_processor.hpp.

344 { return src.sub(rpos); }

References rpos, and src.

◆ curr()

char c4::yml::FilterProcessorInplaceMidExtending::curr ( ) const

inlinenoexcept

Definition at line 346 of file filter_processor.hpp.

346 { _RYML_ASSERT_BASIC(rpos < src.len); return src[rpos]; }

References rpos, and src.

◆ next()

char c4::yml::FilterProcessorInplaceMidExtending::next ( ) const

inlinenoexcept

Definition at line 347 of file filter_processor.hpp.

347 { return rpos+1 < src.len ? src[rpos+1] : '\0'; }

References rpos, and src.

◆ skip() [1/2]

void c4::yml::FilterProcessorInplaceMidExtending::skip ( )

inlinenoexcept

Definition at line 349 of file filter_processor.hpp.

349 { ++rpos; }

References rpos.

◆ skip() [2/2]

void c4::yml::FilterProcessorInplaceMidExtending::skip ( size_t num )

inlinenoexcept

Definition at line 350 of file filter_processor.hpp.

350 { rpos += num; }

References rpos.

◆ set_at()

void c4::yml::FilterProcessorInplaceMidExtending::set_at	(	size_t	pos,
		char	c
	)

inlinenoexcept

Definition at line 352 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(pos < wpos);
         const size_t save = wpos;
         wpos = pos;
         set(c);
         wpos = save;
     }

References set(), and wpos.

◆ set() [1/2]

void c4::yml::FilterProcessorInplaceMidExtending::set ( char c )

inlinenoexcept

Definition at line 360 of file filter_processor.hpp.

     {
         if(wpos < wcap)  // respect write-capacity
         {
             if((wpos <= rpos) && !unfiltered_chars)
                 src.str[wpos] = c;
         }
         else
         {
             _c4dbgip("inplace: add unwritten {}->{}   maxcap={}->{}!", unfiltered_chars, true, maxcap, (wpos+1u > maxcap ? wpos+1u : maxcap));
             unfiltered_chars = true;
         }
         ++wpos;
         maxcap = wpos > maxcap ? wpos : maxcap;
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

◆ set() [2/2]

void c4::yml::FilterProcessorInplaceMidExtending::set	(	char	c,
		size_t	num
	)

inlinenoexcept

Definition at line 375 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(num);
         if(wpos + num <= wcap)  // respect write-capacity
         {
             if((wpos <= rpos) && !unfiltered_chars)
                 memset(src.str + wpos, c, num);
         }
         else
         {
             _c4dbgip("inplace: add unwritten {}->{}   maxcap={}->{}!", unfiltered_chars, true, maxcap, (wpos+num > maxcap ? wpos+num : maxcap));
             unfiltered_chars = true;
         }
         wpos += num;
         maxcap = wpos > maxcap ? wpos : maxcap;
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

◆ copy() [1/2]

void c4::yml::FilterProcessorInplaceMidExtending::copy ( )

inlinenoexcept

Definition at line 392 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(rpos < src.len);
         if(wpos < wcap)  // respect write-capacity
         {
             if((wpos < rpos) && !unfiltered_chars)  // write only if wpos is behind rpos
                 src.str[wpos] = src.str[rpos];
         }
         else
         {
             _c4dbgip("inplace: add unwritten {}->{} (wpos={}!=rpos={})={}  (wpos={}<wcap={})   maxcap={}->{}!", unfiltered_chars, true, wpos, rpos, wpos!=rpos, wpos, wcap, wpos<wcap, maxcap, (wpos+1u > maxcap ? wpos+1u : maxcap));
             unfiltered_chars = true;
         }
         ++rpos;
         ++wpos;
         maxcap = wpos > maxcap ? wpos : maxcap;
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

◆ copy() [2/2]

void c4::yml::FilterProcessorInplaceMidExtending::copy ( size_t num )

inlinenoexcept

Definition at line 409 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(num);
         _RYML_ASSERT_BASIC(rpos+num <= src.len);
         if(wpos + num <= wcap)  // respect write-capacity
         {
             if((wpos < rpos) && !unfiltered_chars)  // write only if wpos is behind rpos
             {
                 if(wpos + num <= rpos) // there is no overlap
                     memcpy(src.str + wpos, src.str + rpos, num);
                 else                   // there is overlap
                     memmove(src.str + wpos, src.str + rpos, num);
             }
         }
         else
         {
             _c4dbgip("inplace: add unwritten {}->{} (wpos={}!=rpos={})={}  (wpos={}<wcap={})  maxcap={}->{}!", unfiltered_chars, true, wpos, rpos, wpos!=rpos, wpos, wcap, wpos<wcap);
             unfiltered_chars = true;
         }
         rpos += num;
         wpos += num;
         maxcap = wpos > maxcap ? wpos : maxcap;
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

◆ translate_esc()

void c4::yml::FilterProcessorInplaceMidExtending::translate_esc ( char c )

inlinenoexcept

Definition at line 433 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(rpos + 2 <= src.len);
         if(wpos < wcap) // respect write-capacity
         {
             if((wpos <= rpos) && !unfiltered_chars)
                 src.str[wpos] = c;
         }
         else
         {
             _c4dbgip("inplace: add unfiltered {}->{}  maxcap={}->{}!", unfiltered_chars, true, maxcap, (wpos+1u > maxcap ? wpos+1u : maxcap));
             unfiltered_chars = true;
         }
         rpos += 2;
         ++wpos;
         maxcap = wpos > maxcap ? wpos : maxcap;
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

◆ translate_esc_bulk()

void c4::yml::FilterProcessorInplaceMidExtending::translate_esc_bulk	(	const char *	s,
		size_t	nw,
		size_t	nr
	)

inlinenoexcept

Definition at line 451 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(nw > 0);
         _RYML_ASSERT_BASIC(nr > 0);
         _RYML_ASSERT_BASIC(nr+1u >= nw);
         const size_t wpos_next = wpos + nw;
         const size_t rpos_next = rpos + nr + 1u; // add 1u to account for the escape character
         if(wpos_next <= wcap)  // respect write-capacity
         {
             if((wpos <= rpos) && !unfiltered_chars)  // write only if wpos is behind rpos
                 memcpy(src.str + wpos, s, nw);
         }
         else
         {
             _c4dbgip("inplace: add unwritten {}->{} (wpos={}!=rpos={})={}  (wpos={}<wcap={})  maxcap={}->{}!", unfiltered_chars, true, wpos, rpos, wpos!=rpos, wpos, wcap, wpos<wcap);
             unfiltered_chars = true;
         }
         rpos = rpos_next;
         wpos = wpos_next;
         maxcap = wpos > maxcap ? wpos : maxcap;
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

◆ translate_esc_extending()

void c4::yml::FilterProcessorInplaceMidExtending::translate_esc_extending	(	const char *	s,
		size_t	nw,
		size_t	nr
	)

inlinenoexcept

Definition at line 473 of file filter_processor.hpp.

     {
         _RYML_ASSERT_BASIC(nw > 0);
         _RYML_ASSERT_BASIC(nr > 0);
         _RYML_ASSERT_BASIC(rpos+nr <= src.len);
         const size_t wpos_next = wpos + nw;
         const size_t rpos_next = rpos + nr + 1u; // add 1u to account for the escape character
         if(wpos_next <= rpos_next) // read and write do not overlap. just do a vanilla copy.
         {
             if((wpos_next <= wcap) && !unfiltered_chars)
                 memcpy(src.str + wpos, s, nw);
             rpos = rpos_next;
             wpos = wpos_next;
             maxcap = wpos > maxcap ? wpos : maxcap;
         }
         else // there is overlap. move the (to-be-read) string to the right.
         {
             const size_t excess = wpos_next - rpos_next;
             _RYML_ASSERT_BASIC(wpos_next > rpos_next);
             if(src.len + excess <= wcap) // ensure we do not go past the end
             {
                 _RYML_ASSERT_BASIC(rpos+nr+excess <= src.len);
                 if(wpos_next <= wcap)
                 {
                     if(!unfiltered_chars)
                     {
                         memmove(src.str + wpos_next, src.str + rpos_next, src.len - rpos_next);
                         memcpy(src.str + wpos, s, nw);
                     }
                     rpos = wpos_next; // wpos, not rpos
                 }
                 else
                 {
                     rpos = rpos_next;
                     //const size_t unw = nw > (nr + 1u) ? nw - (nr + 1u) : 0;
                     _c4dbgip("inplace: add unfiltered {}->{}   maxcap={}->{}!", unfiltered_chars, true);
                     unfiltered_chars = true;
                 }
                 wpos = wpos_next;
                 // extend the string up to capacity
                 src.len += excess;
                 maxcap = wpos > maxcap ? wpos : maxcap;
             }
             else
             {
                 //const size_t unw = nw > (nr + 1u) ? nw - (nr + 1u) : 0;
                 _RYML_ASSERT_BASIC(rpos_next <= src.len);
                 const size_t required_size = wpos_next + (src.len - rpos_next);
                 _c4dbgip("inplace: add unfiltered {}->{}   maxcap={}->{}!", unfiltered_chars, true, maxcap, required_size > maxcap ? required_size : maxcap);
                 _RYML_ASSERT_BASIC(required_size > wcap);
                 unfiltered_chars = true;
                 maxcap = required_size > maxcap ? required_size : maxcap;
                 wpos = wpos_next;
                 rpos = rpos_next;
             }
         }
     }

References maxcap, rpos, src, unfiltered_chars, wcap, and wpos.

Member Data Documentation

◆ src

substr c4::yml::FilterProcessorInplaceMidExtending::src

the subject string

Definition at line 309 of file filter_processor.hpp.

◆ wcap

size_t c4::yml::FilterProcessorInplaceMidExtending::wcap

write capacity - the capacity of the subject string's buffer

Definition at line 310 of file filter_processor.hpp.

◆ rpos

size_t c4::yml::FilterProcessorInplaceMidExtending::rpos

read position

Definition at line 311 of file filter_processor.hpp.

◆ wpos

size_t c4::yml::FilterProcessorInplaceMidExtending::wpos

write position

Definition at line 312 of file filter_processor.hpp.

◆ maxcap

size_t c4::yml::FilterProcessorInplaceMidExtending::maxcap

the max capacity needed for filtering the string. This may be larger than the final string size.

Definition at line 313 of file filter_processor.hpp.

◆ unfiltered_chars

bool c4::yml::FilterProcessorInplaceMidExtending::unfiltered_chars

number of characters that were not added to wpos from lack of capacity

Definition at line 314 of file filter_processor.hpp.

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

/home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.12.1/src/c4/yml/filter_processor.hpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FilterProcessorInplaceMidExtending()

Member Function Documentation

◆ setwpos()

◆ setpos()

◆ set_at_end()

◆ has_more_chars() [1/2]

◆ has_more_chars() [2/2]

◆ result()

◆ sofar()

◆ rem()

◆ curr()

◆ next()

◆ skip() [1/2]

◆ skip() [2/2]

◆ set_at()

◆ set() [1/2]

◆ set() [2/2]

◆ copy() [1/2]

◆ copy() [2/2]

◆ translate_esc()

◆ translate_esc_bulk()

◆ translate_esc_extending()

Member Data Documentation

◆ src

◆ wcap

◆ rpos

◆ wpos

◆ maxcap

◆ unfiltered_chars