an owning string class used by the yaml std event handler (and the YamlScript handler). More...

#include <string.hpp>

Public Types
enum	: id_type { sso_size = RYML_STRING_SSO_SIZE }

Public Member Functions
	string ()

	~string () noexcept

	string (string const &that) RYML_NOEXCEPT

	string (string &&that) noexcept

string &	operator= (string const &that) RYML_NOEXCEPT

string &	operator= (string &&that) noexcept

	operator csubstr () const noexcept

	operator substr () noexcept

const char *	data () const noexcept

id_type	size () const noexcept

id_type	capacity () const noexcept

void	clear ()

void	resize (id_type sz)

void	reserve (id_type sz)

void	append (char c)

void	append (csubstr cs)

void	insert (char c, id_type pos)

void	insert (csubstr cs, id_type pos)

size_t	find_last (csubstr pattern) RYML_NOEXCEPT

void	_free ()

void	_cp (string const *that)

void	_mv (string *that)

Public Attributes
char	m_buf [sso_size]

char *	m_str

id_type	m_size

id_type	m_capacity

Detailed Description

an owning string class used by the yaml std event handler (and the YamlScript handler).

we use this instead of std::string because: 1) this spares the dependency on the standard library 2) enables possibility of adding borrowing semantics (in the future)

Definition at line 32 of file string.hpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum : id_type

Enumerator
sso_size

Definition at line 34 of file string.hpp.

34 : id_type { sso_size = RYML_STRING_SSO_SIZE };

c4::yml::id_type

RYML_ID_TYPE id_type

The type of a node id in the YAML tree; to override the default type, define the macro RYML_ID_TYPE t...

Definition: common.hpp:244

RYML_STRING_SSO_SIZE

#define RYML_STRING_SSO_SIZE

Definition: string.hpp:17

c4::yml::extra::string::sso_size

@ sso_size

Definition: string.hpp:34

Constructor & Destructor Documentation

◆ string() [1/3]

c4::yml::extra::string::string ( )

inline

Definition at line 42 of file string.hpp.

         : m_buf()
         , m_str(m_buf)
         , m_size(0)
         , m_capacity(sso_size)
     {}

◆ ~string()

c4::yml::extra::string::~string ( )

inlinenoexcept

Definition at line 48 of file string.hpp.

     {
         _free();
     }

References _free().

◆ string() [2/3]

c4::yml::extra::string::string ( string const & that )

inline

Definition at line 53 of file string.hpp.

                                              : string()
     {
         resize(that.m_size);
         _cp(&that);
     }

References _cp(), and resize().

◆ string() [3/3]

c4::yml::extra::string::string ( string && that )

inlinenoexcept

Definition at line 59 of file string.hpp.

                                    : string()
     {
         _mv(&that);
     }

References _mv().

Member Function Documentation

◆ operator=() [1/2]

string& c4::yml::extra::string::operator= ( string const & that )

inline

Definition at line 64 of file string.hpp.

     {
         resize(that.m_size);
         _cp(&that);
         return *this;
     }

References _cp(), and resize().

◆ operator=() [2/2]

string& c4::yml::extra::string::operator= ( string && that )

inlinenoexcept

Definition at line 71 of file string.hpp.

     {
         _mv(&that);
         return *this;
     }

References _mv().

◆ operator csubstr()

c4::yml::extra::string::operator csubstr ( ) const

inlinenoexcept

Definition at line 79 of file string.hpp.

79 { return {m_str, m_size}; }

References m_size, and m_str.

◆ operator substr()

c4::yml::extra::string::operator substr ( )

inlinenoexcept

Definition at line 80 of file string.hpp.

80 { return {m_str, m_size}; }

References m_size, and m_str.

◆ data()

const char* c4::yml::extra::string::data ( ) const

inlinenoexcept

Definition at line 84 of file string.hpp.

84 { return m_str; }

References m_str.

◆ size()

id_type c4::yml::extra::string::size ( ) const

inlinenoexcept

Definition at line 85 of file string.hpp.

85 { return m_size; }

References m_size.

◆ capacity()

id_type c4::yml::extra::string::capacity ( ) const

inlinenoexcept

Definition at line 86 of file string.hpp.

86 { return m_capacity; }

References m_capacity.

◆ clear()

void c4::yml::extra::string::clear ( )

inline

Definition at line 88 of file string.hpp.

     {
         m_size = 0;
     }

References m_size.

◆ resize()

void c4::yml::extra::string::resize ( id_type sz )

inline

Definition at line 93 of file string.hpp.

     {
         reserve(sz);
         m_size = sz;
     }

References m_size, and reserve().

◆ reserve()

void c4::yml::extra::string::reserve ( id_type sz )

inline

Definition at line 99 of file string.hpp.

     {
         if(sz <= m_capacity)
             return;
         id_type cap = m_capacity < string::sso_size ? string::sso_size : 2 * m_capacity;
         cap = cap > sz ? cap : sz;
         if(cap <= sso_size)
             return;
         Callbacks cb = get_callbacks();
         char *buf = (char*) _RYML_CB_ALLOC(cb, char, cap);
         if(m_size)
             memcpy(buf, m_str, (size_t)m_size);
         if(m_str != m_buf)
         {
             _RYML_CB_FREE(cb, m_str, char, m_size);
         }
         m_str = buf;
         m_capacity = cap;
     }

References c4::yml::get_callbacks(), m_buf, m_capacity, m_size, m_str, and sso_size.

◆ append() [1/2]

void c4::yml::extra::string::append ( char c )

inline

Definition at line 121 of file string.hpp.

     {
         if(C4_UNLIKELY(m_size == m_capacity))
             reserve(m_size + 1);
         m_str[m_size++] = c;
     }

References m_capacity, m_size, m_str, and reserve().

◆ append() [2/2]

void c4::yml::extra::string::append ( csubstr cs )

inline

Definition at line 127 of file string.hpp.

     {
         if(cs.len)
         {
             const id_type ilen = (id_type)cs.len;
             if(C4_UNLIKELY(m_size + ilen > m_capacity))
                 reserve(m_size + ilen);
             memcpy(m_str + m_size, cs.str, cs.len);
             m_size += ilen;
         }
     }

References m_capacity, m_size, m_str, and reserve().

◆ insert() [1/2]

void c4::yml::extra::string::insert	(	char	c,
		id_type	pos
	)

inline

Definition at line 138 of file string.hpp.

     {
         _RYML_ASSERT_BASIC(pos <= m_size);
         if(pos < m_size)
         {
             if(C4_UNLIKELY(m_size == m_capacity))
                 reserve(m_size + 1);
             char *C4_RESTRICT src = m_str + pos;
             memmove(src + 1, src, m_size - pos);
             *src = c;
             ++m_size;
         }
         else
         {
             append(c);
         }
     }

References append(), m_capacity, m_size, m_str, and reserve().

◆ insert() [2/2]

void c4::yml::extra::string::insert	(	csubstr	cs,
		id_type	pos
	)

inline

Definition at line 155 of file string.hpp.

     {
         _RYML_ASSERT_BASIC(pos <= m_size);
         if(cs.len)
         {
             if(pos < m_size)
             {
                 const id_type ilen = (id_type)cs.len;
                 if(C4_UNLIKELY(m_size + ilen > m_capacity))
                     reserve(m_size + ilen);
                 char *C4_RESTRICT src = m_str + pos;
                 memmove(src + cs.len, src, m_size - pos);
                 memcpy(src, cs.str, cs.len);
                 m_size += ilen;
             }
             else
             {
                 append(cs);
             }
         }
     }

References append(), m_capacity, m_size, m_str, and reserve().

◆ find_last()

size_t c4::yml::extra::string::find_last ( csubstr pattern )

inline

Definition at line 176 of file string.hpp.

     {
         _RYML_ASSERT_BASIC(pattern.len);
         if(m_size >= pattern.len)
         {
             for(size_t i = m_size - pattern.len; i != (size_t)-1; --i)
             {
                 if(m_str[i] == pattern[0])
                 {
                     bool gotit = true;
                     for(size_t j = 1; j < pattern.len; ++j)
                     {
                         if(m_str[i + j] != pattern[j])
                         {
                             gotit = false;
                             break;
                         }
                     }
                     if(gotit)
                         return i;
                 }
             }
         }
         return npos;
     }

References m_size, m_str, and c4::yml::npos.

◆ _free()

void c4::yml::extra::string::_free ( )

inline

Definition at line 204 of file string.hpp.

     {
         _RYML_ASSERT_BASIC(m_str != nullptr); // this structure cannot be memset() to zero
         if(m_str != m_buf)
         {
             _RYML_CB_FREE(get_callbacks(), m_str, char, (size_t)m_capacity);
             m_str = m_buf;
             m_capacity = sso_size;
         }
         _RYML_ASSERT_BASIC(m_capacity == sso_size);
         m_size = 0;
     }

References c4::yml::get_callbacks(), m_buf, m_capacity, m_size, m_str, and sso_size.

◆ _cp()

void c4::yml::extra::string::_cp ( string const * that )

inline

Definition at line 217 of file string.hpp.

     {
         #if RYML_USE_ASSERT
         if(that->m_str != that->m_buf)
         {
             _RYML_ASSERT_BASIC(that->m_capacity > sso_size);
             _RYML_ASSERT_BASIC(that->m_size <= that->m_capacity);
         }
         else
         {
             _RYML_ASSERT_BASIC(that->m_capacity <= sso_size);
             _RYML_ASSERT_BASIC(that->m_size <= that->m_capacity);
         }
         #endif
         memcpy(m_str, that->m_str, that->m_size);
         m_size = that->m_size;
         m_capacity = that->m_size < sso_size ? sso_size : that->m_size;
     }

References m_capacity, m_size, m_str, and sso_size.

◆ _mv()

void c4::yml::extra::string::_mv ( string * that )

inline

Definition at line 236 of file string.hpp.

     {
         if(that->m_str != that->m_buf)
         {
             _RYML_ASSERT_BASIC(that->m_capacity > sso_size);
             _RYML_ASSERT_BASIC(that->m_size <= that->m_capacity);
             m_str = that->m_str;
         }
         else
         {
             _RYML_ASSERT_BASIC(that->m_capacity <= sso_size);
             _RYML_ASSERT_BASIC(that->m_size <= that->m_capacity);
             memcpy(m_buf, that->m_buf, that->m_size);
             m_str = m_buf;
         }
         m_size = that->m_size;
         m_capacity = that->m_capacity;
         // make sure no deallocation happens on destruction
         _RYML_ASSERT_BASIC(that->m_str != this->m_buf);
         that->m_str = that->m_buf;
         that->m_capacity = sso_size;
         that->m_size = 0;
     }

References m_buf, m_capacity, m_size, m_str, and sso_size.

Member Data Documentation

◆ m_buf

char c4::yml::extra::string::m_buf[sso_size]

Definition at line 35 of file string.hpp.

◆ m_str

char* c4::yml::extra::string::m_str

Definition at line 36 of file string.hpp.

◆ m_size

id_type c4::yml::extra::string::m_size

Definition at line 37 of file string.hpp.

◆ m_capacity

id_type c4::yml::extra::string::m_capacity

Definition at line 38 of file string.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_extra/c4/yml/extra/string.hpp

Public Types

Public Member Functions

Public Attributes

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ string() [1/3]

◆ ~string()

◆ string() [2/3]

◆ string() [3/3]

Member Function Documentation

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator csubstr()

◆ operator substr()

◆ data()

◆ size()

◆ capacity()

◆ clear()

◆ resize()

◆ reserve()

◆ append() [1/2]

◆ append() [2/2]

◆ insert() [1/2]

◆ insert() [2/2]

◆ find_last()

◆ _free()

◆ _cp()

◆ _mv()

Member Data Documentation

◆ m_buf

◆ m_str

◆ m_size

◆ m_capacity