c4::yml::FilterProcessorInplaceMidExtending Struct Reference

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
size_t	wcap
	write capacity - the capacity of the subject string's buffer
size_t	rpos
	read position
size_t	wpos
	write position
size_t	maxcap
	the max capacity needed for filtering the string. This may be larger than the final string size.
bool	unfiltered_chars
	number of characters that were not added to wpos from lack of capacity

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

FilterProcessorInplaceEndExtending

Definition at line 301 of file filter_processor.hpp.

Constructor & Destructor Documentation

FilterProcessorInplaceMidExtending()

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

inlinenoexcept

Definition at line 310 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);
    }

Member Function Documentation

setwpos()

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

inlinenoexcept

Definition at line 321 of file filter_processor.hpp.

{ wpos = wpos_; }

setpos()

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

inlinenoexcept

Definition at line 322 of file filter_processor.hpp.

{ rpos = rpos_; wpos = wpos_; }

set_at_end()

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

inlinenoexcept

Definition at line 323 of file filter_processor.hpp.

{ skip(src.len - rpos); }

has_more_chars() [1/2]

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

inlinenoexcept

Definition at line 325 of file filter_processor.hpp.

{ return rpos < src.len; }

has_more_chars() [2/2]

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

inlinenoexcept

Definition at line 326 of file filter_processor.hpp.

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

result()

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

inlinenoexcept

Definition at line 328 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;
    }

sofar()

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

inlinenoexcept

Definition at line 337 of file filter_processor.hpp.

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

rem()

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

inlinenoexcept

Definition at line 338 of file filter_processor.hpp.

{ return src.sub(rpos); }

curr()

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

inlinenoexcept

Definition at line 340 of file filter_processor.hpp.

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

next()

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

inlinenoexcept

Definition at line 341 of file filter_processor.hpp.

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

skip() [1/2]

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

inlinenoexcept

Definition at line 343 of file filter_processor.hpp.

{ ++rpos; }

Referenced by set_at_end().

skip() [2/2]

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

inlinenoexcept

Definition at line 344 of file filter_processor.hpp.

{ rpos += num; }

set_at()

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

inlinenoexcept

Definition at line 346 of file filter_processor.hpp.

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

set() [1/2]

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

inlinenoexcept

Definition at line 354 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;
    }

Referenced by set_at().

set() [2/2]

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

inlinenoexcept

Definition at line 369 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;
    }

copy() [1/2]

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

inlinenoexcept

Definition at line 386 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;
    }

copy() [2/2]

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

inlinenoexcept

Definition at line 403 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;
    }

translate_esc()

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

inlinenoexcept

Definition at line 427 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;
    }

translate_esc_bulk()

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

inlinenoexcept

Definition at line 445 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;
    }

translate_esc_extending()

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

inlinenoexcept

Definition at line 467 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;
            }
        }
    }

Member Data Documentation

src

substr c4::yml::FilterProcessorInplaceMidExtending::src

the subject string

Definition at line 303 of file filter_processor.hpp.

Referenced by FilterProcessorInplaceMidExtending(), copy(), copy(), curr(), has_more_chars(), has_more_chars(), next(), rem(), result(), set(), set(), set_at_end(), sofar(), translate_esc(), translate_esc_bulk(), and translate_esc_extending().

wcap

size_t c4::yml::FilterProcessorInplaceMidExtending::wcap

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

Definition at line 304 of file filter_processor.hpp.

Referenced by FilterProcessorInplaceMidExtending(), copy(), copy(), result(), set(), set(), sofar(), translate_esc(), translate_esc_bulk(), and translate_esc_extending().

rpos

size_t c4::yml::FilterProcessorInplaceMidExtending::rpos

read position

Definition at line 305 of file filter_processor.hpp.

Referenced by copy(), copy(), curr(), has_more_chars(), has_more_chars(), next(), rem(), set(), set(), set_at_end(), setpos(), skip(), skip(), translate_esc(), translate_esc_bulk(), and translate_esc_extending().

wpos

size_t c4::yml::FilterProcessorInplaceMidExtending::wpos

write position

Definition at line 306 of file filter_processor.hpp.

Referenced by copy(), copy(), result(), set(), set(), set_at(), setpos(), setwpos(), sofar(), translate_esc(), translate_esc_bulk(), and translate_esc_extending().

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 307 of file filter_processor.hpp.

Referenced by copy(), copy(), result(), set(), set(), translate_esc(), translate_esc_bulk(), and translate_esc_extending().

unfiltered_chars

bool c4::yml::FilterProcessorInplaceMidExtending::unfiltered_chars

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

Definition at line 308 of file filter_processor.hpp.

Referenced by copy(), copy(), result(), set(), set(), translate_esc(), translate_esc_bulk(), and translate_esc_extending().

---

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

• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/latest/src/c4/yml/filter_processor.hpp