pfc::string8_t< t_alloc >

#include <string_base.h>

Inheritance diagram for pfc::string8_t< t_alloc >:

Public Member Functions
	string8_t ()
	string8_t (const char *p_string)
	string8_t (const char *p_string, t_size p_length)
	string8_t (const t_self &p_string)
	string8_t (const string_base &p_string)
	string8_t (string_part_ref ref)
void	add_string (const char *p_string, t_size p_length=~0)
void	add_string (string_part_ref ref)
void	add_string_ (const char *str)
void	add_string_nc (const char *ptr, t_size len)
void	fix_filename_chars (char def= '_', char leave=0)
void	force_reset ()
t_size	get_length () const throw ()
const char *	get_ptr () const throw ()
void	insert_chars (t_size first, const char *src, t_size count)
void	insert_chars (t_size first, const char *src)
char *	lock_buffer (t_size n)
	operator const char * () const throw ()
const t_self &	operator+= (const char *src)
const t_self &	operator+= (const string_base &src)
const t_self &	operator+= (const t_self &src)
const t_self &	operator+= (string_part_ref src)
const t_self &	operator= (const char *src)
const t_self &	operator= (const string_base &src)
const t_self &	operator= (const t_self &src)
const t_self &	operator= (string_part_ref src)
void	prealloc (t_size p_size)
void	remove_chars (t_size first, t_size count)
t_size	replace_byte (char c1, char c2, t_size start=0)
t_size	replace_char (unsigned c1, unsigned c2, t_size start=0)
t_size	replace_nontext_chars (char p_replace= '_')
void	set_char (unsigned offset, char c)
void	set_string (const char *p_string, t_size p_length=~0)
void	set_string (string_part_ref ref)
void	set_string_ (const char *str)
void	set_string_nc (const char *ptr, t_size len)
void	truncate (t_size len)
void	unlock_buffer ()
Public Member Functions inherited from pfc::string_base
string_base &	_formatter () const
void	add_filename (const char *fn)
const char *	c_str () const
void	convert_to_lower_ascii (const char *src, char replace= '?')
void	delimit (const char *c)
void	end_with (char c)
void	end_with_slash ()
bool	ends_with (char c) const
t_size	find_first (char p_char, t_size p_start=0) const
t_size	find_first (const char *p_string, t_size p_start=0) const
t_size	find_last (char p_char, t_size p_start=~0) const
t_size	find_last (const char *p_string, t_size p_start=~0) const
void	fix_dir_separator (char c= '\\')
bool	fix_eol (const char *append=" (...)", t_size start=0)
bool	has_prefix (const char *prefix) const
bool	has_prefix_i (const char *prefix) const
bool	has_suffix (const char *suffix) const
bool	has_suffix_i (const char *suffix) const
bool	is_empty () const
bool	is_valid_utf8 () const
char	last_char () const
t_size	length () const
bool	limit_length (t_size length_in_chars, const char *append=" (...)")
	operator const char * () const
bool	operator!= (const string_base &p_other) const
const string_base &	operator+= (const char *src)
const string_base &	operator+= (const string_base &src)
bool	operator< (const string_base &p_other) const
bool	operator<= (const string_base &p_other) const
const string_base &	operator= (const char *src)
const string_base &	operator= (const string_base &src)
bool	operator== (const string_base &p_other) const
bool	operator> (const string_base &p_other) const
bool	operator>= (const string_base &p_other) const
t_size	replace_string (const char *replace, const char *replaceWith, t_size start=0)
void	reset ()
t_size	scan_filename () const
void	set_string_ (const char *str)
void	skip_trailing_char (unsigned c= ' ')
const char *	toString () const
bool	truncate_eol (t_size start=0)
void	truncate_filename ()
void	truncate_last_char ()
void	truncate_number_suffix ()
void	truncate_to_parent_path ()
Public Member Functions inherited from pfc::string_receiver
void	add_byte (char c)
void	add_char (t_uint32 c)
void	add_chars (t_uint32 p_char, t_size p_count)
void	add_string_ (const char *str)

Static Public Member Functions
static void	g_swap (t_self &p_item1, t_self &p_item2)

Protected Member Functions
const char *	_get_ptr () const throw ()
void	makespace (t_size s)
Protected Member Functions inherited from pfc::string_base
	string_base ()
	~string_base ()
Protected Member Functions inherited from pfc::string_receiver
	string_receiver ()
	~string_receiver ()

Protected Attributes
pfc::array_t< char, t_alloc >	m_data
t_size	used

Private Types
typedef string8_t< t_alloc >	t_self

Detailed Description

template<template< typename > class t_alloc>
class pfc::string8_t< t_alloc >

Definition at line 321 of file string_base.h.

Member Typedef Documentation

template<template< typename > class t_alloc>

typedef string8_t<t_alloc> pfc::string8_t< t_alloc >::t_self

private

Definition at line 323 of file string_base.h.

Constructor & Destructor Documentation

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::string8_t ( )

inline

Definition at line 373 of file string_base.h.

: used(0) {}

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::string8_t ( const char *  p_string )

inline

Definition at line 374 of file string_base.h.

: used(0) {set_string_(p_string);}

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::string8_t ( const char *  p_string, t_size  p_length  )

inline

Definition at line 375 of file string_base.h.

: used(0) {set_string(p_string,p_length);}

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::string8_t ( const t_self &  p_string )

inline

Definition at line 376 of file string_base.h.

: used(0) {set_string(p_string);}

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::string8_t ( const string_base &  p_string )

inline

Definition at line 377 of file string_base.h.

: used(0) {set_string(p_string);}

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::string8_t ( string_part_ref  ref )

inline

Definition at line 378 of file string_base.h.

: used(0) {set_string(ref);}

Member Function Documentation

template<template< typename > class t_alloc>

const char* pfc::string8_t< t_alloc >::_get_ptr ( ) const throw ( )

inlineprotected

Definition at line 340 of file string_base.h.

{return used > 0 ? m_data.get_ptr() : "";}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::add_string ( const char *  p_string, t_size  p_length = ~0  )

virtual

Implements pfc::string_base.

Definition at line 4 of file string8_impl.h.

{
    if (m_data.is_owned(ptr)) {
        add_string(string8(ptr,len));
    } else {
        len = strlen_max(ptr,len);
        add_string_nc(ptr, len);
    }
}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::add_string ( string_part_ref  ref )

inline

Definition at line 388 of file string_base.h.

{add_string_nc(ref.m_ptr, ref.m_len);}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::add_string_ ( const char *  str )

inline

Definition at line 344 of file string_base.h.

{add_string_nc(str, strlen(str));}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::add_string_nc ( const char *  ptr, t_size  len  )

inline

Definition at line 353 of file string_base.h.

                                                         {
            PFC_ASSERT(! m_data.is_owned(ptr) );
            PFC_ASSERT( strlen_max(ptr, len) == len );
            makespace(used+len+1);
            pfc::memcpy_t(m_data.get_ptr() + used,ptr,len);
            used+=len;
            m_data[used]=0;
        }

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::fix_filename_chars	(	char	def = '_',
		char	leave = 0
	)

Definition at line 32 of file string8_impl.h.

{
    t_size n;
    for(n=0;n<used;n++)
        if (m_data[n]!=leave && pfc::is_path_bad_char(m_data[n])) m_data[n]=def;
}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::force_reset ( )

inline

Definition at line 424 of file string_base.h.

{used=0;m_data.force_reset();}

template<template< typename > class t_alloc>

static void pfc::string8_t< t_alloc >::g_swap ( t_self &  p_item1, t_self &  p_item2  )

inlinestatic

Definition at line 426 of file string_base.h.

                                                                     {
            pfc::swap_t(p_item1.m_data,p_item2.m_data);
            pfc::swap_t(p_item1.used,p_item2.used);
        }

template<template< typename > class t_alloc>

t_size pfc::string8_t< t_alloc >::get_length ( ) const throw ( )

inlinevirtual

Reimplemented from pfc::string_base.

Definition at line 395 of file string_base.h.

{return used;}

template<template< typename > class t_alloc>

const char* pfc::string8_t< t_alloc >::get_ptr ( ) const throw ( )

inlinevirtual

Implements pfc::string_base.

Definition at line 382 of file string_base.h.

{return _get_ptr();}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::insert_chars	(	t_size	first,
		const char *	src,
		t_size	count
	)

Definition at line 55 of file string8_impl.h.

{
    if (first > used) first = used;

    makespace(used+count+1);
    t_size n;
    for(n=used;(int)n>=(int)first;n--)
        m_data[n+count] = m_data[n];
    for(n=0;n<count;n++)
        m_data[first+n] = src[n];

    used+=count;
}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::insert_chars	(	t_size	first,
		const char *	src
	)

Definition at line 70 of file string8_impl.h.

{insert_chars(first,src,strlen(src));}

template<template< typename > class t_alloc>

char* pfc::string8_t< t_alloc >::lock_buffer ( t_size  n )

inlinevirtual

Implements pfc::string_base.

Definition at line 409 of file string_base.h.

        {
            if (n + 1 == 0) throw exception_overflow();
            makespace(n+1);
            pfc::memset_t(m_data,(char)0);
            return m_data.get_ptr();;
        }

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::makespace ( t_size  s )

inlineprotected

Definition at line 328 of file string_base.h.

                                        {
            if (t_alloc<char>::alloc_prioritizes_speed) {
                m_data.set_size(s);
            } else {
                const t_size old_size = m_data.get_size();
                if (old_size < s)
                    m_data.set_size(s + 16);
                else if (old_size > s + 32)
                    m_data.set_size(s);
            }
        }

template<template< typename > class t_alloc>

pfc::string8_t< t_alloc >::operator const char * ( ) const throw ( )

inline

Definition at line 371 of file string_base.h.

{return _get_ptr();}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator+= ( const char *  src )

inline

Definition at line 362 of file string_base.h.

{add_string_(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator+= ( const string_base &  src )

inline

Definition at line 364 of file string_base.h.

{add_string(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator+= ( const t_self &  src )

inline

Definition at line 366 of file string_base.h.

{add_string(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator+= ( string_part_ref  src )

inline

Definition at line 369 of file string_base.h.

{add_string(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator= ( const char *  src )

inline

Definition at line 361 of file string_base.h.

{set_string_(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator= ( const string_base &  src )

inline

Definition at line 363 of file string_base.h.

{set_string(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator= ( const t_self &  src )

inline

Definition at line 365 of file string_base.h.

{set_string(src);return *this;}

template<template< typename > class t_alloc>

const t_self& pfc::string8_t< t_alloc >::operator= ( string_part_ref  src )

inline

Definition at line 368 of file string_base.h.

{set_string(src);return *this;}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::prealloc ( t_size  p_size )

inline

Definition at line 380 of file string_base.h.

{m_data.prealloc(p_size+1);}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::remove_chars	(	t_size	first,
		t_size	count
	)

Definition at line 40 of file string8_impl.h.

{
    if (first>used) first = used;
    if (first+count>used) count = used-first;
    if (count>0)
    {
        t_size n;
        for(n=first+count;n<=used;n++)
            m_data[n-count]=m_data[n];
        used -= count;
        makespace(used+1);
    }
}

template<template< typename > class t_alloc>

t_size pfc::string8_t< t_alloc >::replace_byte	(	char	c1,
		char	c2,
		t_size	start = 0
	)

Definition at line 85 of file string8_impl.h.

{
    PFC_ASSERT(c1 != 0); PFC_ASSERT(c2 != 0);
    t_size n, ret = 0;
    for(n=start;n<used;n++)
    {
        if (m_data[n] == c1) {m_data[n] = c2; ret++;}
    }
    return ret;
}

template<template< typename > class t_alloc>

t_size pfc::string8_t< t_alloc >::replace_char	(	unsigned	c1,
		unsigned	c2,
		t_size	start = 0
	)

Definition at line 97 of file string8_impl.h.

{
    if (c1 < 128 && c2 < 128) return replace_byte((char)c1,(char)c2,start);

    string8 temp(get_ptr()+start);
    truncate(start);
    const char * ptr = temp;
    t_size rv = 0;
    while(*ptr)
    {
        unsigned test;
        t_size delta = utf8_decode_char(ptr,test);
        if (delta==0 || test==0) break;
        if (test == c1) {test = c2;rv++;}
        add_char(test);
        ptr += delta;
    }
    return rv;
}

template<template< typename > class t_alloc>

t_size pfc::string8_t< t_alloc >::replace_nontext_chars

(

char

p_replace = '_'

)

Definition at line 74 of file string8_impl.h.

{
    t_size ret = 0;
    for(t_size n=0;n<used;n++)
    {
        if ((unsigned char)m_data[n] < 32) {m_data[n] = p_replace; ret++; }
    }
    return ret;
}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::set_char	(	unsigned	offset,
		char	c
	)

Definition at line 25 of file string8_impl.h.

{
    if (!c) truncate(offset);
    else if (offset<used) m_data[offset]=c;
}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::set_string ( const char *  p_string, t_size  p_length = ~0  )

virtual

Reimplemented from pfc::string_base.

Definition at line 15 of file string8_impl.h.

                                                               {
    if (m_data.is_owned(ptr)) {
        set_string_(string8(ptr,len));
    } else {
        len = strlen_max(ptr,len);
        set_string_nc(ptr, len);
    }
}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::set_string ( string_part_ref  ref )

inline

Definition at line 387 of file string_base.h.

{set_string_nc(ref.m_ptr, ref.m_len);}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::set_string_ ( const char *  str )

inline

Definition at line 343 of file string_base.h.

{set_string_nc(str, strlen(str));}

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::set_string_nc ( const char *  ptr, t_size  len  )

inline

Definition at line 345 of file string_base.h.

                                                         {
            PFC_ASSERT(! m_data.is_owned(ptr) );
            PFC_ASSERT( strlen_max(ptr, len) == len );
            makespace(len+1);
            pfc::memcpy_t(m_data.get_ptr(),ptr,len);
            used=len;
            m_data[used]=0;
        }

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::truncate ( t_size  len )

inlinevirtual

Implements pfc::string_base.

Definition at line 390 of file string_base.h.

        {
            if (used>len) {used=len;m_data[len]=0;makespace(used+1);}
        }

template<template< typename > class t_alloc>

void pfc::string8_t< t_alloc >::unlock_buffer ( )

inlinevirtual

Implements pfc::string_base.

Definition at line 417 of file string_base.h.

                             {
            if (m_data.get_size() > 0) {
                used=strlen(m_data.get_ptr());
                makespace(used+1);
            }
        }

Field Documentation

template<template< typename > class t_alloc>

pfc::array_t<char,t_alloc> pfc::string8_t< t_alloc >::m_data

protected

Definition at line 325 of file string_base.h.

template<template< typename > class t_alloc>

t_size pfc::string8_t< t_alloc >::used

protected

Definition at line 326 of file string_base.h.

---

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

• pfc/string_base.h
• pfc/string8_impl.h