Small String Optimization (SSO) implementation. More...

#include <small_string.h>

Collaboration diagram for kcenon::logger::small_string< SSO_SIZE >:

Classes
union	data_union

struct	memory_stats
	Get memory usage statistics. More...

Public Member Functions
	small_string () noexcept
	Default constructor.

	small_string (const char *str)
	Construct from C-string.

	small_string (const std::string &str)
	Construct from std::string.

	small_string (std::string_view str)
	Construct from string_view.

	small_string (const small_string &other)
	Copy constructor.

	small_string (small_string &&other) noexcept
	Move constructor.

	~small_string ()
	Destructor.

small_string &	operator= (const small_string &other)
	Copy assignment.

small_string &	operator= (small_string &&other) noexcept
	Move assignment.

void	assign (const char *str, size_t len)
	Assign from string data.

const char *	c_str () const noexcept
	Get C-string pointer.

const char *	data () const noexcept
	Get data pointer.

size_t	size () const noexcept
	Get size.

size_t	length () const noexcept
	Get length (same as size)

bool	empty () const noexcept
	Check if empty.

bool	is_small () const noexcept
	Check if using small string optimization.

size_t	capacity () const noexcept
	Get capacity.

void	clear () noexcept
	Clear the string.

void	reserve (size_t new_capacity)
	Reserve capacity.

void	append (const char *str, size_t len)
	Append a string.

void	append (const std::string &str)
	Append a string.

small_string &	operator+= (const char *str)
	Append operator.

small_string &	operator+= (const std::string &str)
	Append operator.

std::string	to_string () const
	Convert to std::string.

	operator std::string_view () const noexcept
	Implicit conversion to string_view.

bool	operator== (const small_string &other) const noexcept
	Equality comparison.

bool	operator!= (const small_string &other) const noexcept
	Inequality comparison.

bool	operator== (const std::string &str) const noexcept
	Comparison with std::string.

memory_stats	get_memory_stats () const noexcept

Static Public Attributes
static constexpr size_t	SSO_CAPACITY = SSO_SIZE - 1

Static Private Member Functions
static size_t	calculate_capacity (size_t required)
	Calculate capacity for heap allocation.

Private Attributes
union kcenon::logger::small_string::data_union	data_

size_t	size_

bool	is_small_

Detailed Description

template<size_t SSO_SIZE = 256>
class kcenon::logger::small_string< SSO_SIZE >

Small String Optimization (SSO) implementation.

This class implements a string with Small String Optimization. Strings smaller than SSO_CAPACITY are stored inline, avoiding heap allocation. Larger strings use heap allocation like std::string.

Template Parameters

SSO_SIZE Size threshold for SSO (default 256 bytes)

Definition at line 32 of file small_string.h.

Constructor & Destructor Documentation

◆ small_string() [1/6]

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::small_string ( )

inlinenoexcept

Default constructor.

Definition at line 39 of file small_string.h.

                            : size_(0), is_small_(true) {
        data_.small[0] = '\0';
    }

References kcenon::logger::small_string< SSO_SIZE >::data_, and kcenon::logger::small_string< SSO_SIZE >::data_union::small.

◆ small_string() [2/6]

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::small_string ( const char * str )

inline

Construct from C-string.

Definition at line 46 of file small_string.h.

                                  : small_string() {
        if (str) {
            assign(str, std::strlen(str));
        }
    }

References kcenon::logger::small_string< SSO_SIZE >::assign().

Here is the call graph for this function:

◆ small_string() [3/6]

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::small_string ( const std::string & str )

inline

Construct from std::string.

Definition at line 55 of file small_string.h.

                                       : small_string() {
        assign(str.data(), str.size());
    }

References kcenon::logger::small_string< SSO_SIZE >::assign().

Here is the call graph for this function:

◆ small_string() [4/6]

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::small_string ( std::string_view str )

inline

Construct from string_view.

Definition at line 62 of file small_string.h.

                                     : small_string() {
        assign(str.data(), str.size());
    }

References kcenon::logger::small_string< SSO_SIZE >::assign().

Here is the call graph for this function:

◆ small_string() [5/6]

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::small_string ( const small_string< SSO_SIZE > & other )

inline

Copy constructor.

Definition at line 69 of file small_string.h.

                                            : small_string() {
        if (other.is_small_) {
            std::memcpy(data_.small, other.data_.small, other.size_ + 1);
            size_ = other.size_;
            is_small_ = true;
        } else {
            assign(other.data(), other.size());
        }
    }

References kcenon::logger::small_string< SSO_SIZE >::is_small_.

◆ small_string() [6/6]

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::small_string ( small_string< SSO_SIZE > && other )

inlinenoexcept

Move constructor.

Definition at line 82 of file small_string.h.

        : size_(other.size_), is_small_(other.is_small_) {
        if (is_small_) {
            std::memcpy(data_.small, other.data_.small, size_ + 1);
        } else {
            data_.heap.ptr = other.data_.heap.ptr;
            data_.heap.capacity = other.data_.heap.capacity;
            other.data_.heap.ptr = nullptr;
            other.size_ = 0;
            other.is_small_ = true;
        }
    }

References kcenon::logger::small_string< SSO_SIZE >::data_union::capacity, kcenon::logger::small_string< SSO_SIZE >::data_, kcenon::logger::small_string< SSO_SIZE >::data_union::heap, kcenon::logger::small_string< SSO_SIZE >::is_small_, kcenon::logger::small_string< SSO_SIZE >::data_union::ptr, kcenon::logger::small_string< SSO_SIZE >::size_, and kcenon::logger::small_string< SSO_SIZE >::data_union::small.

◆ ~small_string()

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::~small_string ( )

inline

Destructor.

Definition at line 98 of file small_string.h.

                    {
        if (!is_small_ && data_.heap.ptr) {
            delete[] data_.heap.ptr;
        }
    }

References kcenon::logger::small_string< SSO_SIZE >::data_, kcenon::logger::small_string< SSO_SIZE >::data_union::heap, kcenon::logger::small_string< SSO_SIZE >::is_small_, and kcenon::logger::small_string< SSO_SIZE >::data_union::ptr.

Member Function Documentation

◆ append() [1/2]

template<size_t SSO_SIZE = 256>

void kcenon::logger::small_string< SSO_SIZE >::append	(	const char *	str,
		size_t	len )

inline

Append a string.

Definition at line 267 of file small_string.h.

                                             {
        size_t new_size = size_ + len;
        
        if (new_size <= SSO_CAPACITY && is_small_) {
            // Can still use SSO
            std::memcpy(data_.small + size_, str, len);
            data_.small[new_size] = '\0';
            size_ = new_size;
        } else {
            // Need heap allocation
            if (is_small_ || data_.heap.capacity < new_size + 1) {
                // Need to reallocate
                size_t new_capacity = calculate_capacity(new_size);
                char* new_ptr = new char[new_capacity];
                
                // Copy existing data
                std::memcpy(new_ptr, data(), size_);
                // Append new data
                std::memcpy(new_ptr + size_, str, len);
                new_ptr[new_size] = '\0';
                
                // Clean up old allocation
                if (!is_small_ && data_.heap.ptr) {
                    delete[] data_.heap.ptr;
                }
                
                data_.heap.ptr = new_ptr;
                data_.heap.capacity = new_capacity;
                is_small_ = false;
            } else {
                // Existing heap buffer is large enough
                std::memcpy(data_.heap.ptr + size_, str, len);
                data_.heap.ptr[new_size] = '\0';
            }
            size_ = new_size;
        }
    }

Referenced by kcenon::logger::small_string< SSO_SIZE >::append(), kcenon::logger::small_string< SSO_SIZE >::operator+=(), and kcenon::logger::small_string< SSO_SIZE >::operator+=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append() [2/2]

template<size_t SSO_SIZE = 256>

void kcenon::logger::small_string< SSO_SIZE >::append ( const std::string & str )

inline

Append a string.

Definition at line 308 of file small_string.h.

                                      {
        append(str.data(), str.size());
    }

References kcenon::logger::small_string< SSO_SIZE >::append().

Here is the call graph for this function:

◆ assign()

template<size_t SSO_SIZE = 256>

void kcenon::logger::small_string< SSO_SIZE >::assign	(	const char *	str,
		size_t	len )

inline

Assign from string data.

Definition at line 143 of file small_string.h.

                                             {
        if (len <= SSO_CAPACITY) {
            // Use small string optimization
            if (!is_small_ && data_.heap.ptr) {
                delete[] data_.heap.ptr;
            }
            std::memcpy(data_.small, str, len);
            data_.small[len] = '\0';
            size_ = len;
            is_small_ = true;
        } else {
            // Use heap allocation
            if (is_small_ || data_.heap.capacity < len + 1) {
                // Need to allocate new buffer
                if (!is_small_ && data_.heap.ptr) {
                    delete[] data_.heap.ptr;
                }
                
                size_t new_capacity = calculate_capacity(len);
                data_.heap.ptr = new char[new_capacity];
                data_.heap.capacity = new_capacity;
                is_small_ = false;
            }
            
            std::memcpy(data_.heap.ptr, str, len);
            data_.heap.ptr[len] = '\0';
            size_ = len;
        }
    }

Referenced by kcenon::logger::small_string< SSO_SIZE >::operator=(), kcenon::logger::small_string< SSO_SIZE >::small_string(), kcenon::logger::small_string< SSO_SIZE >::small_string(), and kcenon::logger::small_string< SSO_SIZE >::small_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ c_str()

template<size_t SSO_SIZE = 256>

const char * kcenon::logger::small_string< SSO_SIZE >::c_str ( ) const

inlinenoexcept

Get C-string pointer.

Definition at line 176 of file small_string.h.

                                       {
        return data();
    }

References kcenon::logger::small_string< SSO_SIZE >::data().

Here is the call graph for this function:

◆ calculate_capacity()

template<size_t SSO_SIZE = 256>

static size_t kcenon::logger::small_string< SSO_SIZE >::calculate_capacity ( size_t required )

inlinestaticprivate

Calculate capacity for heap allocation.

Definition at line 390 of file small_string.h.

                                                      {
        // Round up to next power of 2 for better allocation patterns
        size_t capacity = required + 1; // +1 for null terminator
        capacity = capacity * 3 / 2; // 1.5x growth factor
        
        // Align to 16 bytes for better memory alignment
        return (capacity + 15) & ~15;
    }

References kcenon::logger::small_string< SSO_SIZE >::capacity().

Referenced by kcenon::logger::small_string< SSO_SIZE >::append(), kcenon::logger::small_string< SSO_SIZE >::assign(), and kcenon::logger::small_string< SSO_SIZE >::reserve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ capacity()

template<size_t SSO_SIZE = 256>

size_t kcenon::logger::small_string< SSO_SIZE >::capacity ( ) const

inlinenoexcept

Get capacity.

Definition at line 218 of file small_string.h.

                                     {
        return is_small_ ? SSO_CAPACITY : data_.heap.capacity - 1;
    }

References kcenon::logger::small_string< SSO_SIZE >::data_union::capacity, kcenon::logger::small_string< SSO_SIZE >::data_, kcenon::logger::small_string< SSO_SIZE >::data_union::heap, kcenon::logger::small_string< SSO_SIZE >::is_small_, and kcenon::logger::small_string< SSO_SIZE >::SSO_CAPACITY.

Referenced by kcenon::logger::small_string< SSO_SIZE >::calculate_capacity(), kcenon::logger::small_string< SSO_SIZE >::get_memory_stats(), and kcenon::logger::small_string< SSO_SIZE >::reserve().

Here is the caller graph for this function:

◆ clear()

template<size_t SSO_SIZE = 256>

void kcenon::logger::small_string< SSO_SIZE >::clear ( )

inlinenoexcept

Clear the string.

Definition at line 225 of file small_string.h.

                          {
        if (!is_small_ && data_.heap.ptr) {
            data_.heap.ptr[0] = '\0';
        } else {
            data_.small[0] = '\0';
        }
        size_ = 0;
    }

References kcenon::logger::small_string< SSO_SIZE >::data_, kcenon::logger::small_string< SSO_SIZE >::data_union::heap, kcenon::logger::small_string< SSO_SIZE >::is_small_, kcenon::logger::small_string< SSO_SIZE >::data_union::ptr, kcenon::logger::small_string< SSO_SIZE >::size_, and kcenon::logger::small_string< SSO_SIZE >::data_union::small.

◆ data()

template<size_t SSO_SIZE = 256>

const char * kcenon::logger::small_string< SSO_SIZE >::data ( ) const

inlinenoexcept

Get data pointer.

Definition at line 183 of file small_string.h.

                                      {
        return is_small_ ? data_.small : data_.heap.ptr;
    }

References kcenon::logger::small_string< SSO_SIZE >::data_, kcenon::logger::small_string< SSO_SIZE >::data_union::heap, kcenon::logger::small_string< SSO_SIZE >::is_small_, kcenon::logger::small_string< SSO_SIZE >::data_union::ptr, and kcenon::logger::small_string< SSO_SIZE >::data_union::small.

Referenced by kcenon::logger::small_string< SSO_SIZE >::append(), kcenon::logger::small_string< SSO_SIZE >::c_str(), kcenon::logger::small_string< SSO_SIZE >::operator std::string_view(), kcenon::logger::small_string< SSO_SIZE >::operator=(), kcenon::logger::small_string< SSO_SIZE >::operator==(), kcenon::logger::small_string< SSO_SIZE >::operator==(), kcenon::logger::small_string< SSO_SIZE >::reserve(), content_filter::should_log(), and kcenon::logger::small_string< SSO_SIZE >::to_string().

Here is the caller graph for this function:

◆ empty()

template<size_t SSO_SIZE = 256>

bool kcenon::logger::small_string< SSO_SIZE >::empty ( ) const

inlinenoexcept

Check if empty.

Definition at line 204 of file small_string.h.

                                {
        return size_ == 0;
    }

References kcenon::logger::small_string< SSO_SIZE >::size_.

◆ get_memory_stats()

template<size_t SSO_SIZE = 256>

memory_stats kcenon::logger::small_string< SSO_SIZE >::get_memory_stats ( ) const

inlinenoexcept

Definition at line 376 of file small_string.h.

                                                   {
        memory_stats stats;
        stats.string_size = size_;
        stats.capacity = capacity();
        stats.is_small = is_small_;
        stats.heap_bytes_used = is_small_ ? 0 : data_.heap.capacity;
        stats.total_bytes = sizeof(*this) + stats.heap_bytes_used;
        return stats;
    }

Here is the call graph for this function:

◆ is_small()

template<size_t SSO_SIZE = 256>

bool kcenon::logger::small_string< SSO_SIZE >::is_small ( ) const

inlinenoexcept

Check if using small string optimization.

Definition at line 211 of file small_string.h.

                                   {
        return is_small_;
    }

References kcenon::logger::small_string< SSO_SIZE >::is_small_.

◆ length()

template<size_t SSO_SIZE = 256>

size_t kcenon::logger::small_string< SSO_SIZE >::length ( ) const

inlinenoexcept

Get length (same as size)

Definition at line 197 of file small_string.h.

                                   {
        return size_;
    }

References kcenon::logger::small_string< SSO_SIZE >::size_.

◆ operator std::string_view()

template<size_t SSO_SIZE = 256>

kcenon::logger::small_string< SSO_SIZE >::operator std::string_view ( ) const

inlinenoexcept

Implicit conversion to string_view.

Definition at line 338 of file small_string.h.

                                             {
        return std::string_view(data(), size_);
    }

References kcenon::logger::small_string< SSO_SIZE >::data(), and kcenon::logger::small_string< SSO_SIZE >::size_.

Here is the call graph for this function:

◆ operator!=()

template<size_t SSO_SIZE = 256>

bool kcenon::logger::small_string< SSO_SIZE >::operator!= ( const small_string< SSO_SIZE > & other ) const

inlinenoexcept

Inequality comparison.

Definition at line 353 of file small_string.h.

                                                              {
        return !(*this == other);
    }

◆ operator+=() [1/2]

template<size_t SSO_SIZE = 256>

small_string & kcenon::logger::small_string< SSO_SIZE >::operator+= ( const char * str )

inline

Append operator.

Definition at line 315 of file small_string.h.

                                              {
        append(str, std::strlen(str));
        return *this;
    }

References kcenon::logger::small_string< SSO_SIZE >::append().

Here is the call graph for this function:

◆ operator+=() [2/2]

template<size_t SSO_SIZE = 256>

small_string & kcenon::logger::small_string< SSO_SIZE >::operator+= ( const std::string & str )

inline

Append operator.

Definition at line 323 of file small_string.h.

                                                   {
        append(str);
        return *this;
    }

References kcenon::logger::small_string< SSO_SIZE >::append().

Here is the call graph for this function:

◆ operator=() [1/2]

template<size_t SSO_SIZE = 256>

small_string & kcenon::logger::small_string< SSO_SIZE >::operator= ( const small_string< SSO_SIZE > & other )

inline

Copy assignment.

Definition at line 107 of file small_string.h.

                                                       {
        if (this != &other) {
            assign(other.data(), other.size());
        }
        return *this;
    }

References kcenon::logger::small_string< SSO_SIZE >::assign(), kcenon::logger::small_string< SSO_SIZE >::data(), and kcenon::logger::small_string< SSO_SIZE >::size().

Here is the call graph for this function:

◆ operator=() [2/2]

template<size_t SSO_SIZE = 256>

small_string & kcenon::logger::small_string< SSO_SIZE >::operator= ( small_string< SSO_SIZE > && other )

inlinenoexcept

Move assignment.

Definition at line 117 of file small_string.h.

                                                           {
        if (this != &other) {
            // Clean up current heap allocation if any
            if (!is_small_ && data_.heap.ptr) {
                delete[] data_.heap.ptr;
            }
            
            size_ = other.size_;
            is_small_ = other.is_small_;
            
            if (is_small_) {
                std::memcpy(data_.small, other.data_.small, size_ + 1);
            } else {
                data_.heap.ptr = other.data_.heap.ptr;
                data_.heap.capacity = other.data_.heap.capacity;
                other.data_.heap.ptr = nullptr;
                other.size_ = 0;
                other.is_small_ = true;
            }
        }
        return *this;
    }

References kcenon::logger::small_string< SSO_SIZE >::data_union::capacity, kcenon::logger::small_string< SSO_SIZE >::data_, kcenon::logger::small_string< SSO_SIZE >::data_union::heap, kcenon::logger::small_string< SSO_SIZE >::is_small_, kcenon::logger::small_string< SSO_SIZE >::data_union::ptr, kcenon::logger::small_string< SSO_SIZE >::size_, and kcenon::logger::small_string< SSO_SIZE >::data_union::small.

◆ operator==() [1/2]

template<size_t SSO_SIZE = 256>

bool kcenon::logger::small_string< SSO_SIZE >::operator== ( const small_string< SSO_SIZE > & other ) const

inlinenoexcept

Equality comparison.

Definition at line 345 of file small_string.h.

                                                              {
        return size_ == other.size_ && 
               std::memcmp(data(), other.data(), size_) == 0;
    }

References kcenon::logger::small_string< SSO_SIZE >::data(), and kcenon::logger::small_string< SSO_SIZE >::size_.

Here is the call graph for this function:

◆ operator==() [2/2]

template<size_t SSO_SIZE = 256>

bool kcenon::logger::small_string< SSO_SIZE >::operator== ( const std::string & str ) const

inlinenoexcept

Comparison with std::string.

Definition at line 360 of file small_string.h.

                                                         {
        return size_ == str.size() && 
               std::memcmp(data(), str.data(), size_) == 0;
    }

References kcenon::logger::small_string< SSO_SIZE >::data(), and kcenon::logger::small_string< SSO_SIZE >::size_.

Here is the call graph for this function:

◆ reserve()

template<size_t SSO_SIZE = 256>

void kcenon::logger::small_string< SSO_SIZE >::reserve ( size_t new_capacity )

inline

Reserve capacity.

Definition at line 237 of file small_string.h.

                                      {
        if (new_capacity <= capacity()) {
            return;
        }
        
        if (new_capacity <= SSO_CAPACITY) {
            // Already using SSO, no need to reserve
            return;
        }
        
        // Need heap allocation
        size_t actual_capacity = calculate_capacity(new_capacity);
        char* new_ptr = new char[actual_capacity];
        
        // Copy existing data
        std::memcpy(new_ptr, data(), size_ + 1);
        
        // Clean up old allocation
        if (!is_small_ && data_.heap.ptr) {
            delete[] data_.heap.ptr;
        }
        
        data_.heap.ptr = new_ptr;
        data_.heap.capacity = actual_capacity;
        is_small_ = false;
    }

Here is the call graph for this function:

◆ size()

template<size_t SSO_SIZE = 256>

size_t kcenon::logger::small_string< SSO_SIZE >::size ( ) const

inlinenoexcept

Get size.

Definition at line 190 of file small_string.h.

                                 {
        return size_;
    }

References kcenon::logger::small_string< SSO_SIZE >::size_.

Referenced by kcenon::logger::small_string< SSO_SIZE >::operator=(), and content_filter::should_log().

Here is the caller graph for this function:

◆ to_string()

template<size_t SSO_SIZE = 256>

std::string kcenon::logger::small_string< SSO_SIZE >::to_string ( ) const

inline

Convert to std::string.

Definition at line 331 of file small_string.h.

                                {
        return std::string(data(), size_);
    }

References kcenon::logger::small_string< SSO_SIZE >::data(), and kcenon::logger::small_string< SSO_SIZE >::size_.

Referenced by kcenon::logger::buffered_writer::copy_entry(), kcenon::logger::copy_log_entry(), kcenon::logger::compact_formatter::format(), kcenon::logger::json_formatter::format(), kcenon::logger::logfmt_formatter::format(), kcenon::logger::timestamp_formatter::format(), kcenon::logger::console_writer::format_entry(), kcenon::logger::file_writer::format_entry(), kcenon::logger::network_writer::format_for_network(), kcenon::logger::base_writer::format_log_entry(), kcenon::logger::template_formatter::resolve_placeholder(), kcenon::logger::filters::regex_filter::should_log(), kcenon::logger::log_filter::should_log(), security_filter::should_log(), kcenon::logger::sampling::log_sampler::should_sample(), kcenon::logger::async::high_performance_async_writer::write(), kcenon::logger::encrypted_writer::write(), kcenon::logger::network_writer::write(), kcenon::logger::otlp_writer::write(), and kcenon::logger::critical_writer::write_to_wal().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ data_

template<size_t SSO_SIZE = 256>

union kcenon::logger::small_string::data_union kcenon::logger::small_string< SSO_SIZE >::data_

private

◆ is_small_

template<size_t SSO_SIZE = 256>

bool kcenon::logger::small_string< SSO_SIZE >::is_small_

private

Definition at line 414 of file small_string.h.

◆ size_

template<size_t SSO_SIZE = 256>

size_t kcenon::logger::small_string< SSO_SIZE >::size_

private

Definition at line 413 of file small_string.h.

◆ SSO_CAPACITY

template<size_t SSO_SIZE = 256>

size_t kcenon::logger::small_string< SSO_SIZE >::SSO_CAPACITY = SSO_SIZE - 1

staticconstexpr

Definition at line 34 of file small_string.h.

Referenced by kcenon::logger::small_string< SSO_SIZE >::append(), kcenon::logger::small_string< SSO_SIZE >::assign(), kcenon::logger::small_string< SSO_SIZE >::capacity(), and kcenon::logger::small_string< SSO_SIZE >::reserve().

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

include/kcenon/logger/core/small_string.h

Classes

Public Member Functions

Static Public Attributes

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ small_string() [1/6]

◆ small_string() [2/6]

◆ small_string() [3/6]

◆ small_string() [4/6]

◆ small_string() [5/6]

◆ small_string() [6/6]

◆ ~small_string()

Member Function Documentation

◆ append() [1/2]

◆ append() [2/2]

◆ assign()

◆ c_str()

◆ calculate_capacity()

◆ capacity()

◆ clear()

◆ data()

◆ empty()

◆ get_memory_stats()

◆ is_small()

◆ length()

◆ operator std::string_view()

◆ operator!=()

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ reserve()

◆ size()

◆ to_string()

Member Data Documentation

◆ data_

◆ is_small_

◆ size_

◆ SSO_CAPACITY