c4::yml::TagCache Struct Reference

Accelerator structure to reduce memory requirements by enabling reuse of resolved tags. More...

#include <tag.hpp>

Classes
struct	Entry
struct	LookupResult

Public Types
using	Entries = detail::stack<Entry>
using	const_iterator = id_type

Public Member Functions
	TagCache () noexcept
LookupResult	find (csubstr tag, id_type doc_id, id_type linear_threshold=Entries::sso_size) const noexcept
void	add (csubstr tag, csubstr resolved, id_type doc_id, const_iterator pos) RYML_NOEXCEPT
void	clear () noexcept

Detailed Description

Accelerator structure to reduce memory requirements by enabling reuse of resolved tags.

Definition at line 70 of file tag.hpp.

Member Typedef Documentation

Entries

using c4::yml::TagCache::Entries = detail::stack<Entry>

Definition at line 78 of file tag.hpp.

const_iterator

using c4::yml::TagCache::const_iterator = id_type

Definition at line 79 of file tag.hpp.

Constructor & Destructor Documentation

TagCache()

c4::yml::TagCache::TagCache ( )

inlinenoexcept

Definition at line 89 of file tag.hpp.

: m_entries() {}

Member Function Documentation

find()

TagCache::LookupResult c4::yml::TagCache::find ( csubstr tag, id_type doc_id, id_type linear_threshold = Entries::sso_size ) const

noexcept

Definition at line 537 of file tag.cpp.

{
    LookupResult ret = {};
    id_type sz = m_entries.size();
    if(sz < linear_threshold) // do a linear search on small size
    {
        for(size_t i = 0; i < sz; ++i)
        {
            Entry const& C4_RESTRICT e = m_entries[i];
            if(e.tag == tag && e.doc_id == doc_id)
            {
                ret.resolved = e.resolved;
                ret.pos = i;
                return ret;
            }
            else if(e.tag > tag || ((e.tag == tag) && e.doc_id > doc_id))
            {
                ret.pos = i;
                return ret;
            }
        }
        ret.pos = sz;
    }
    else // do a binary search on larger size
    {
        id_type first = 0;
        id_type count = sz;
        while(count)
        {
            id_type halfsz = count / id_type(2);
            id_type mid = first + halfsz;
            _RYML_ASSERT_BASIC_(m_entries.m_callbacks, mid < sz);
            Entry const& C4_RESTRICT e = m_entries[mid];
            if(e.tag < tag || (e.tag == tag && e.doc_id < doc_id))
            {
                first = mid + 1;
                _RYML_ASSERT_BASIC_(m_entries.m_callbacks, count >= halfsz + 1);
                count -= halfsz + 1;
            }
            else
            {
                count = halfsz;
            }
        }
        ret.pos = first;
        if(first < sz)
        {
            Entry const& C4_RESTRICT e = m_entries[first];
            if(e.tag == tag && e.doc_id == doc_id)
            {
                ret.resolved = m_entries[first].resolved;
            }
        }
    }
    return ret;
}

add()

void c4::yml::TagCache::add	(	csubstr	tag,
		csubstr	resolved,
		id_type	doc_id,
		const_iterator	pos )

Definition at line 594 of file tag.cpp.

{
    const id_type sz = m_entries.size();
    _RYML_ASSERT_BASIC_(m_entries.m_callbacks, pos <= sz);
    _RYML_ASSERT_BASIC_(m_entries.m_callbacks, pos == sz || tag < m_entries[pos].tag || (tag == m_entries[pos].tag && doc_id < m_entries[pos].doc_id));
    m_entries.resize(sz + 1);
    if(pos < sz)
        memmove(m_entries.m_stack + pos + 1, m_entries.m_stack + pos, (sz - pos) * sizeof(Entry));
    m_entries.m_stack[pos].tag = tag;
    m_entries.m_stack[pos].resolved = resolved;
    m_entries.m_stack[pos].doc_id = doc_id;
    _c4dbgpf("tagcache: add entry @pos={}:  docid={}  {} -> {}", pos, doc_id, tag, _maybe_null_str(resolved));
}

clear()

void c4::yml::TagCache::clear ( )

inlinenoexcept

Definition at line 93 of file tag.hpp.

{ m_entries.clear(); }

---

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

• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.14.0/src/c4/yml/tag.hpp
• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.14.0/src/c4/yml/tag.cpp