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_standard >	pfc::string8

typedef string8_t< pfc::alloc_fast >	pfc::string8_fast

typedef string8_t< pfc::alloc_fast_aggressive >	pfc::string8_fast_aggressive

typedef string8_t< pfc::alloc_fast_aggressive >	pfc::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_base &	operator<< (pfc::string_base &p_fmt, const char *p_source)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, pfc::string_part_ref source)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, short p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, unsigned short p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, int p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, unsigned p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, long p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, unsigned long p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, long long p_val)

pfc::string_base &	operator<< (pfc::string_base &p_fmt, unsigned long long p_val)

pfc::string_base &	operator<< (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_base &	operator<< (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_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)

template<>
const char *	pfc::stringToPtr (std::string 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 ()