foobar2000 SDK  2015-08-03
Data Structures | Namespaces | Typedefs | Functions
string_base.h File Reference

Go to the source code of this file.

Data Structures

class  pfc::__splitStringSimple_arrayWrapper< t_array >
 
class  pfc::__splitStringSimple_calculateSubstringCount
 
class  pfc::__splitStringSimple_listWrapper< t_list >
 
class  pfc::_splitStringSimple_check< t_param >
 
class  pfc::_splitStringSimple_check< char >
 
class  pfc::_splitStringSimple_check< const char * >
 
class  pfc::comparator_naturalSort
 
class  pfc::comparator_strcmp
 
class  pfc::comparator_stricmp_ascii
 
class  pfc::format_array
 
class  pfc::format_char
 
class  pfc::format_file_size_short
 
class  pfc::format_fixedpoint
 
class  pfc::format_float
 
class  pfc::format_hex
 
class  pfc::format_hex_lowercase
 
class  pfc::format_hexdump
 
class  pfc::format_hexdump_ex
 
class  pfc::format_hexdump_lowercase
 
class  pfc::format_int
 
class  pfc::format_pad_left< t_stringbuffer >
 
class  pfc::format_pad_right< t_stringbuffer >
 
class  pfc::format_time
 
class  pfc::format_time_ex
 
class  pfc::format_uint
 
class  pfc::string8_t< t_alloc >
 
class  pfc::string_base
 
class  pfc::string_base_ref
 
class  pfc::string_buffer
 
class  pfc::string_directory
 
class  pfc::string_extension
 
class  pfc::string_filename
 
class  pfc::string_filename_ext
 
class  pfc::string_fixed_t< max_length >
 
struct  pfc::string_part_ref
 
class  pfc::string_printf
 
class  pfc::string_printf_va
 
class  pfc::string_receiver
 
class  pfc::string_replace_extension
 
class  pfc::string_simple_t< t_char >
 
class  pfc::traits_t< string8_t< t_alloc > >
 
class  pfc::traits_t< string_simple_t< t_char > >
 

Namespaces

 pfc
 

Typedefs

typedef string8_t< pfc::alloc_standardpfc::string8
 
typedef string8_t< pfc::alloc_fastpfc::string8_fast
 
typedef string8_t< pfc::alloc_fast_aggressivepfc::string8_fast_aggressive
 
typedef string8_t< pfc::alloc_fast_aggressivepfc::string8_fastalloc
 
typedef string8_fastalloc pfc::string_formatter
 
typedef string_simple_t< char > pfc::string_simple
 

Functions

template<typename t_char >
int pfc::_strcmp_partial_ex (const t_char *p_string, t_size p_string_length, const t_char *p_substring, t_size p_substring_length) throw ()
 
t_size pfc::_strParamLen (const char *str)
 
template<typename char_t >
char_t pfc::ascii_tolower (char_t c)
 
char pfc::ascii_tolower_lookup (char c)
 
template<typename char_t >
char_t pfc::ascii_toupper (char_t c)
 
template<typename t_uint >
t_uint pfc::atodec (const char *in, t_size inLen)
 
template<typename t_uint >
t_uint pfc::atohex (const char *in, t_size inLen)
 
t_int64 pfc::atoi64_ex (const char *src, t_size len)
 
t_uint64 pfc::atoui64_ex (const char *src, t_size len)
 
unsigned pfc::atoui_ex (const char *p_string, t_size p_string_len)
 
bool pfc::char_is_ascii_alpha (char p_char) throw ()
 
bool pfc::char_is_ascii_alpha_lower (char p_char) throw ()
 
bool pfc::char_is_ascii_alpha_upper (char p_char) throw ()
 
bool pfc::char_is_ascii_alphanumeric (char p_char) throw ()
 
bool pfc::char_is_hexnumeric (char p_char) throw ()
 
template<typename char_t >
bool pfc::char_is_numeric (char_t p_char) throw ()
 
unsigned pfc::char_to_dec (char c)
 
unsigned pfc::char_to_hex (char c)
 
uint32_t pfc::charLower (uint32_t param)
 
uint32_t pfc::charUpper (uint32_t param)
 
void pfc::convert_to_lower_ascii (const char *src, t_size max, char *out, char replace)
 
void pfc::float_to_string (char *out, t_size out_max, double val, unsigned precision, bool b_sign)
 
char pfc::format_hex_char (unsigned p_val)
 
char pfc::format_hex_char_lowercase (unsigned p_val)
 
bool pfc::has_path_bad_chars (const char *param)
 
bool pfc::is_lower_ascii (const char *param)
 
bool pfc::is_multiline (const char *p_string, t_size p_len)
 
bool pfc::is_path_bad_char (unsigned c)
 
bool pfc::is_path_separator (unsigned c)
 
bool pfc::is_valid_utf8 (const char *param, t_size max=~0)
 
int pfc::naturalSortCompare (const char *s1, const char *s2) throw ()
 
int pfc::naturalSortCompareI (const char *s1, const char *s2) throw ()
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, const char *p_source)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, pfc::string_part_ref source)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, short p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, unsigned short p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, int p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, unsigned p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, long p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, unsigned long p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, long long p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, unsigned long long p_val)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, double p_val)
 
template<template< typename > class t_alloc>
pfc::string8_t< t_alloc > & operator<< (pfc::string8_t< t_alloc > &str, pfc::string_part_ref src)
 
pfc::string_baseoperator<< (pfc::string_base &p_fmt, std::exception const &p_exception)
 
template<template< typename > class t_alloc>
pfc::string8_t< t_alloc > & operator<< (pfc::string8_t< t_alloc > &str, const char *src)
 
template<template< typename > class t_alloc>
pfc::string8_t< t_alloc > & operator<< (pfc::string8_t< t_alloc > &str, pfc::string_base const &src)
 
double pfc::parse_timecode (const char *in)
 
void pfc::recover_invalid_utf8 (const char *src, char *out, unsigned replace)
 
t_size pfc::scan_filename (const char *ptr)
 
t_size pfc::skip_utf8_chars (const char *ptr, t_size count) throw ()
 
template<typename t_out >
void pfc::splitStringByChar (t_out &out, const char *str, char c)
 
template<typename t_out >
void pfc::splitStringByLines (t_out &out, const char *str)
 
template<typename t_out >
void pfc::splitStringBySubstring (t_out &out, const char *str, const char *split)
 
template<typename t_output , typename t_splitCheck >
void pfc::splitStringEx (t_output &p_output, const t_splitCheck &p_check, const char *p_string, t_size p_stringLen=~0)
 
template<typename t_array , typename t_split >
void pfc::splitStringSimple_toArray (t_array &p_output, t_split p_split, const char *p_string, t_size p_stringLen=~0)
 
template<typename t_list , typename t_split >
void pfc::splitStringSimple_toList (t_list &p_output, t_split p_split, const char *p_string, t_size p_stringLen=~0)
 
int pfc::strcmp_ex (const char *p1, t_size n1, const char *p2, t_size n2) throw ()
 
int pfc::strcmp_nc (const char *p1, size_t n1, const char *p2, size_t n2) throw ()
 
int pfc::strcmp_partial (const char *str, const char *substr) throw ()
 
int pfc::strcmp_partial_ex (const char *str, t_size strLen, const char *substr, t_size substrLen) throw ()
 
template<typename t_char >
int pfc::strcmp_partial_ex_t (const t_char *p_string, t_size p_string_length, const t_char *p_substring, t_size p_substring_length) throw ()
 
template<typename t_char >
int pfc::strcmp_partial_t (const t_char *p_string, const t_char *p_substring) throw ()
 
template<typename char_t >
void pfc::strcpy_t (char_t *out, const char_t *in)
 
t_size pfc::strcpy_utf8_truncate (const char *src, char *out, t_size maxbytes)
 
char * pfc::strDup (const char *src)
 
char * pfc::strdup_n (const char *src, t_size len)
 
int pfc::stricmp_ascii (const char *s1, const char *s2) throw ()
 
int pfc::stricmp_ascii_ex (const char *const s1, t_size const len1, const char *const s2, t_size const len2) throw ()
 
int pfc::stricmp_ascii_partial (const char *str, const char *substr) throw ()
 
t_size pfc::string_find_first (const char *p_string, char p_tofind, t_size p_start)
 
t_size pfc::string_find_first (const char *p_string, const char *p_tofind, t_size p_start)
 
t_size pfc::string_find_first_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start)
 
t_size pfc::string_find_first_ex (const char *p_string, t_size p_string_length, const char *p_tofind, t_size p_tofind_length, t_size p_start)
 
t_size pfc::string_find_first_nc (const char *p_string, t_size p_string_length, char c, t_size p_start)
 
t_size pfc::string_find_first_nc (const char *p_string, t_size p_string_length, const char *p_tofind, t_size p_tofind_length, t_size p_start)
 
t_size pfc::string_find_last (const char *p_string, char p_tofind, t_size p_start)
 
t_size pfc::string_find_last (const char *p_string, const char *p_tofind, t_size p_start)
 
t_size pfc::string_find_last_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start)
 
t_size pfc::string_find_last_ex (const char *p_string, t_size p_string_length, const char *p_tofind, t_size p_tofind_length, t_size p_start)
 
bool pfc::string_has_prefix (const char *string, const char *prefix)
 
bool pfc::string_has_prefix_i (const char *string, const char *prefix)
 
bool pfc::string_has_suffix (const char *string, const char *suffix)
 
bool pfc::string_has_suffix_i (const char *string, const char *suffix)
 
bool pfc::string_is_numeric (const char *p_string, t_size p_length) throw ()
 
string_part_ref pfc::string_part (const char *ptr, t_size len)
 
double pfc::string_to_float (const char *src, t_size max)
 
template<typename t_source >
static void pfc::stringCombine (pfc::string_base &out, t_source const &in, const char *separator, const char *separatorLast)
 
int pfc::stringCompareCaseInsensitive (const char *s1, const char *s2)
 
int pfc::stringCompareCaseInsensitiveEx (string_part_ref s1, string_part_ref s2)
 
bool pfc::stringEqualsI_ascii (const char *p1, const char *p2) throw ()
 
bool pfc::stringEqualsI_utf8 (const char *p1, const char *p2) throw ()
 
template<typename TChar , t_size len, typename TSource >
void pfc::stringToBuffer (TChar(&buffer)[len], const TSource &source)
 
template<typename TChar , t_size len, typename TSource >
void pfc::stringToBufferGuarded (TChar(&buffer)[len], const TSource &source)
 
void pfc::stringToLowerAppend (string_base &out, const char *src, t_size len)
 
template<typename T >
const char * pfc::stringToPtr (T const &val)
 
const char * pfc::stringToPtr (const char *val)
 
template<typename T >
static string_part_ref pfc::stringToRef (T const &val)
 
string_part_ref pfc::stringToRef (string_part_ref val)
 
string_part_ref pfc::stringToRef (const char *val)
 
void pfc::stringToUpperAppend (string_base &out, const char *src, t_size len)
 
t_size pfc::strlen_max (const char *ptr, t_size max) throw ()
 
template<typename t_char >
t_size pfc::strlen_max_t (const t_char *ptr, t_size max)
 
t_size pfc::strlen_utf8 (const char *s, t_size num=~0) throw ()
 
t_size pfc::strstr_ex (const char *p_string, t_size p_string_len, const char *p_substring, t_size p_substring_len) throw ()
 
template<>
void pfc::swap_t (string8 &p_item1, string8 &p_item2)
 
t_size pfc::tcslen_max (const TCHAR *ptr, t_size max)
 
void pfc::urlEncode (pfc::string_base &out, const char *in)
 
void pfc::urlEncodeAppend (pfc::string_base &out, const char *in)
 
void pfc::urlEncodeAppendRaw (pfc::string_base &out, const char *in, t_size inSize)
 
t_size pfc::utf16_decode_char (const char16_t *p_source, unsigned *p_out, t_size p_source_length=~0) throw ()
 
t_size pfc::utf16_decode_char (const wchar_t *p_source, unsigned *p_out, t_size p_source_length=~0) throw ()
 
t_size pfc::utf16_encode_char (unsigned c, char16_t *out) throw ()
 
t_size pfc::utf16_encode_char (unsigned c, wchar_t *out) throw ()
 
bool pfc::utf8_advance (const char *&var) throw ()
 
bool pfc::utf8_advance (char *&var) throw ()
 
t_size pfc::utf8_char_len (const char *s, t_size max=~0) throw ()
 
t_size pfc::utf8_char_len_from_header (char c) throw ()
 
const char * pfc::utf8_char_next (const char *src) throw ()
 
char * pfc::utf8_char_next (char *src) throw ()
 
t_size pfc::utf8_chars_to_bytes (const char *string, t_size count) throw ()
 
t_size pfc::utf8_decode_char (const char *src, unsigned &out, t_size src_bytes) throw ()
 
t_size pfc::utf8_decode_char (const char *src, unsigned &out) throw ()
 
t_size pfc::utf8_encode_char (unsigned c, char *out) throw ()
 
unsigned pfc::utf8_get_char (const char *src)
 
t_size pfc::wcslen_max (const wchar_t *ptr, t_size max) throw ()
 
t_size pfc::wide_decode_char (const wchar_t *p_source, unsigned *p_out, t_size p_source_length=~0) throw ()
 
t_size pfc::wide_encode_char (unsigned c, wchar_t *out) throw ()
 

Data Structure Documentation

class pfc::_splitStringSimple_check

template<typename t_param>
class pfc::_splitStringSimple_check< t_param >

Definition at line 898 of file string_base.h.

Function Documentation

pfc::string_base& operator<< ( pfc::string_base p_fmt,
const char *  p_source 
)
inline

Definition at line 724 of file string_base.h.

724 {p_fmt.add_string_(p_source); return p_fmt;}
void add_string_(const char *str)
Definition: string_base.h:39
pfc::string_base& operator<< ( pfc::string_base p_fmt,
pfc::string_part_ref  source 
)
inline

Definition at line 725 of file string_base.h.

725 {p_fmt.add_string(source.m_ptr, source.m_len); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
const char * m_ptr
Definition: string_base.h:13
pfc::string_base& operator<< ( pfc::string_base p_fmt,
short  p_val 
)
inline

Definition at line 726 of file string_base.h.

726 {p_fmt.add_string(pfc::format_int(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
unsigned short  p_val 
)
inline

Definition at line 727 of file string_base.h.

727 {p_fmt.add_string(pfc::format_uint(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
int  p_val 
)
inline

Definition at line 728 of file string_base.h.

728 {p_fmt.add_string(pfc::format_int(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
unsigned  p_val 
)
inline

Definition at line 729 of file string_base.h.

729 {p_fmt.add_string(pfc::format_uint(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
long  p_val 
)
inline

Definition at line 730 of file string_base.h.

730 {p_fmt.add_string(pfc::format_int(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
unsigned long  p_val 
)
inline

Definition at line 731 of file string_base.h.

731 {p_fmt.add_string(pfc::format_uint(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
long long  p_val 
)
inline

Definition at line 732 of file string_base.h.

732 {p_fmt.add_string(pfc::format_int(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
unsigned long long  p_val 
)
inline

Definition at line 733 of file string_base.h.

733 {p_fmt.add_string(pfc::format_uint(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
pfc::string_base& operator<< ( pfc::string_base p_fmt,
double  p_val 
)
inline

Definition at line 734 of file string_base.h.

734 {p_fmt.add_string(pfc::format_float(p_val)); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
template<template< typename > class t_alloc>
pfc::string8_t<t_alloc>& operator<< ( pfc::string8_t< t_alloc > &  str,
pfc::string_part_ref  src 
)
inline

Definition at line 739 of file string_base.h.

739 {str.add_string(src); return str;}
void add_string(const char *p_string, t_size p_length=~0)
Definition: string8_impl.h:4
pfc::string_base& operator<< ( pfc::string_base p_fmt,
std::exception const &  p_exception 
)
inline

Definition at line 735 of file string_base.h.

735 {p_fmt.add_string(p_exception.what()); return p_fmt;}
virtual void add_string(const char *p_string, t_size p_length=~0)=0
template<template< typename > class t_alloc>
pfc::string8_t<t_alloc>& operator<< ( pfc::string8_t< t_alloc > &  str,
const char *  src 
)
inline

Definition at line 737 of file string_base.h.

737 {str.add_string_(src); return str;}
void add_string_(const char *str)
Definition: string_base.h:344
template<template< typename > class t_alloc>
pfc::string8_t<t_alloc>& operator<< ( pfc::string8_t< t_alloc > &  str,
pfc::string_base const &  src 
)
inline

Definition at line 738 of file string_base.h.

738 {str.add_string(src); return str;}
void add_string(const char *p_string, t_size p_length=~0)
Definition: string8_impl.h:4