pfc Namespace Reference

Classes
class	pfc::traits_t< file_info_impl_utils::info_entry >
class	pfc::traits_t< file_info_impl_utils::meta_entry >
class	pfc::traits_t< hasher_md5_state >
class	pfc::traits_t< hasher_md5_result >
class	pfc::traits_t< service_ptr_t< T > >
class	alloc_dummy
class	alloc_simple
	Simple inefficient fully portable allocator. More...
class	__array_fast_helper_t
class	alloc_standard
class	alloc_fast
class	alloc_fast_aggressive
class	alloc_fixed
class	alloc_hybrid
class	pfc::traits_t< alloc_simple< t_item > >
class	pfc::traits_t< __array_fast_helper_t< t_item > >
class	pfc::traits_t< alloc_standard< t_item > >
class	pfc::traits_t< alloc_fast< t_item > >
class	pfc::traits_t< alloc_fast_aggressive< t_item > >
class	array_staticsize_t
	Special simplififed version of array class that avoids stepping on landmines with classes without public copy operators/constructors. More...
class	array_t
class	array_hybrid_t
class	pfc::traits_t< array_staticsize_t< t_item > >
class	pfc::traits_t< array_t< t_item, t_alloc > >
class	comparator_array
class	avltree_t
class	pfc::traits_t< avltree_t< t_storage, t_comparator > >
class	bsearch_callback
class	bsearch_callback_impl_simple_t
class	bsearch_callback_impl_permutation_t
class	__EncodeIntHelper
class	pfc::__EncodeIntHelper< TInt, 1, IsBigEndian >
class	pfc::__EncodeIntHelper< TInt, 0, IsBigEndian >
class	__DecodeIntHelper
class	pfc::__DecodeIntHelper< TInt, 1, IsBigEndian >
class	pfc::__DecodeIntHelper< TInt, 0, IsBigEndian >
class	chain_list_simple_t
class	comparator_chainlist
class	chain_list_t
class	com_ptr_t
class	GUID_from_text
class	print_guid
class	instance_tracker_server_t
class	instance_tracker_client_t
class	pfc::sized_int_t< 1 >
class	pfc::sized_int_t< 2 >
class	pfc::sized_int_t< 4 >
class	pfc::sized_int_t< 8 >
class	int_specs_signed_t
class	int_specs_unsigned_t
class	pfc::int_specs_t< char >
class	pfc::int_specs_t< unsigned char >
class	pfc::int_specs_t< short >
class	pfc::int_specs_t< unsigned short >
class	pfc::int_specs_t< int >
class	pfc::int_specs_t< unsigned int >
class	pfc::int_specs_t< long >
class	pfc::int_specs_t< unsigned long >
class	pfc::int_specs_t< long long >
class	pfc::int_specs_t< unsigned long long >
class	pfc::int_specs_t< wchar_t >
class	list_base_const_t
class	list_single_ref_t
class	list_partial_ref_t
class	list_const_array_t
class	list_const_cast_t
class	ptr_list_const_array_t
class	list_const_ptr_t
class	list_base_t
class	list_impl_t
class	list_t
class	list_hybrid_t
class	ptr_list_const_cast_t
class	list_const_permutation_t
class	list_permutation_t
class	__map_overwrite_wrapper
class	map_t
class	pfc::traits_t< map_t< t_storage_from, t_storage_to, t_comparator > >
class	vartoggle_t
class	refcounter
class	releaser_delete
class	releaser_delete_array
class	releaser_free
class	ptrholder_t
	Assumes t_freefunc to never throw exceptions. More...
class	pfc::ptrholder_t< void, t_releaser >
class	__exception_with_message_t
class	pfc::assert_same_type< p_type, p_type >
class	is_same_type
class	pfc::is_same_type< p_type, p_type >
class	pfc::__static_assert_switcher_t< true >
class	exception_overflow
class	exception_bug_check
class	exception_unexpected_recursion
class	exception_not_implemented
class	exception_dynamic_assert
class	comparator_default
	For use with avltree/map etc. More...
class	comparator_memcmp
class	__list_to_array_enumerator
class	enumerator_add_item
class	ptr_list_t
class	ptr_list_hybrid_t
class	rc_container_base
class	rc_container_t
class	rcptr_const_t
class	rcptr_t
class	traits_rcptr
class	pfc::traits_t< rcptr_const_t< T > >
class	pfc::traits_t< rcptr_t< T > >
class	refcounted_object_root
class	refcounted_object_ptr_t
class	pfc::traits_t< refcounted_object_ptr_t< T > >
class	reorder_callback
class	reorder_callback_impl_t
class	reorder_callback_impl_delta
class	reorder_callback_impl_ptr_t
class	sort_callback
class	sort_callback_stabilizer
class	sort_callback_impl_simple_wrap_t
class	sort_callback_impl_auto_wrap_t
class	sort_callback_impl_permutation_wrap_t
class	string_receiver
class	string_base
class	string_fixed_t
class	string8_t
class	pfc::traits_t< string8_t< t_alloc > >
class	string_buffer
class	format_time
class	format_time_ex
class	string_filename
class	string_filename_ext
class	string_extension
class	string_replace_extension
class	string_directory
class	format_float
class	format_int
class	format_uint
class	format_hex
class	format_hex_lowercase
class	format_hexdump
class	format_hexdump_lowercase
class	format_fixedpoint
class	format_char
class	format_pad_left
class	format_pad_right
class	string_simple_t
class	pfc::traits_t< string_simple_t< t_char > >
class	comparator_strcmp
class	comparator_stricmp_ascii
class	string_list_impl
class	traits_default
class	traits_default_movable
class	traits_rawobject
class	traits_vtable
class	traits_t
class	combine_traits
class	traits_combined
class	pfc::traits_t< T * >
class	pfc::traits_t< char >
class	pfc::traits_t< unsigned char >
class	pfc::traits_t< wchar_t >
class	pfc::traits_t< short >
class	pfc::traits_t< unsigned short >
class	pfc::traits_t< int >
class	pfc::traits_t< unsigned int >
class	pfc::traits_t< long >
class	pfc::traits_t< unsigned long >
class	pfc::traits_t< long long >
class	pfc::traits_t< unsigned long long >
class	pfc::traits_t< bool >
class	pfc::traits_t< float >
class	pfc::traits_t< double >
class	pfc::traits_t< GUID >
class	pfc::traits_t< T[p_count]>
Typedefs
typedef vartoggle_t< bool >	booltoggle
typedef std::exception	exception
typedef ptr_list_t< void >	ptr_list
typedef string8_t < pfc::alloc_standard >	string8
typedef string8_t < pfc::alloc_fast >	string8_fast
typedef string8_t < pfc::alloc_fast_aggressive >	string8_fast_aggressive
typedef string8_t < pfc::alloc_fast_aggressive >	string8_fastalloc
typedef string8_fastalloc	string_formatter
typedef string_simple_t< char >	string_simple
typedef list_base_const_t < const char * >	string_list_const
Enumerations
enum	{ byte_order_is_big_endian = 1, byte_order_is_little_endian = (!( 1 )) }
Functions
static void *	raw_malloc (t_size p_size)
static void	raw_free (void *p_block) throw ()
static void *	raw_realloc (void *p_ptr, t_size p_size)
static bool	raw_realloc_inplace (void *p_block, t_size p_size) throw ()
template<typename T>
t_size	calc_array_width (t_size p_width)
template<typename T>
T *	__raw_malloc_t (t_size p_size)
template<typename T>
void	__raw_free_t (T *p_block) throw ()
template<typename T>
T *	__raw_realloc_t (T *p_block, t_size p_size)
template<typename T>
bool	__raw_realloc_inplace_t (T *p_block, t_size p_size)
template<typename t_exception, typename t_int>
t_int	safe_shift_left_t (t_int p_val, t_size p_shift=1)
template<typename t_item>
bool	is_pointer_in_range (const t_item *p_buffer, t_size p_buffer_size, const void *p_pointer)
template<typename t_to, typename t_from>
void	copy_array_t (t_to &p_to, const t_from &p_from)
template<typename t_array, typename t_value>
void	fill_array_t (t_array &p_array, const t_value &p_value)
PFC_DLL_EXPORT bool	bsearch (t_size p_count, bsearch_callback const &p_callback, t_size &p_result)
template<typename t_container, typename t_compare, typename t_param>
bool	bsearch_t (t_size p_count, const t_container &p_container, t_compare p_compare, const t_param &p_param, t_size &p_index)
template<typename t_container, typename t_compare, typename t_param, typename t_permutation>
bool	bsearch_permutation_t (t_size p_count, const t_container &p_container, t_compare p_compare, const t_param &p_param, const t_permutation &p_permutation, t_size &p_index)
template<typename t_container, typename t_compare, typename t_param>
bool	bsearch_range_t (const t_size p_count, const t_container &p_container, t_compare p_compare, const t_param &p_param, t_size &p_range_base, t_size &p_range_count)
template<typename t_callback>
bool	bsearch_inline_t (t_size p_count, const t_callback &p_callback, t_size &p_result)
template<typename t_buffer, typename t_value>
bool	bsearch_simple_inline_t (const t_buffer &p_buffer, t_size p_count, t_value const &p_value, t_size &p_result)
void	byteswap_raw (void *p_buffer, t_size p_bytes)
template<typename T>
T	byteswap_t (T p_source)
template<>
char	byteswap_t< char > (char p_source)
template<>
unsigned char	byteswap_t< unsigned char > (unsigned char p_source)
template<>
t_uint16	byteswap_t< t_uint16 > (t_uint16 p_source)
template<>
t_int16	byteswap_t< t_int16 > (t_int16 p_source)
template<>
t_uint32	byteswap_t< t_uint32 > (t_uint32 p_source)
template<>
t_int32	byteswap_t< t_int32 > (t_int32 p_source)
template<>
t_uint64	byteswap_t< t_uint64 > (t_uint64 p_source)
template<>
t_int64	byteswap_t< t_int64 > (t_int64 p_source)
template<>
wchar_t	byteswap_t< wchar_t > (wchar_t p_source)
template<>
float	byteswap_t< float > (float p_source)
template<>
double	byteswap_t< double > (double p_source)
template<>
GUID	byteswap_t< GUID > (GUID p_guid)
template<typename T>
T	byteswap_if_be_t (T p_param)
template<typename T>
T	byteswap_if_le_t (T p_param)
template<typename TInt>
void	encode_little_endian (t_uint8 *p_buffer, TInt p_value)
template<typename TInt>
void	encode_big_endian (t_uint8 *p_buffer, TInt p_value)
template<typename TInt>
void	decode_little_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt>
void	decode_big_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt>
TInt	decode_little_endian (const t_uint8 *p_buffer)
template<typename TInt>
TInt	decode_big_endian (const t_uint8 *p_buffer)
int	guid_compare (const GUID &g1, const GUID &g2)
bool	guid_equal (const GUID &g1, const GUID &g2)
template<>
int	compare_t< GUID, GUID > (const GUID &p_item1, const GUID &p_item2)
PFC_DLL_EXPORT void	print_hex_raw (const void *buffer, unsigned bytes, char *p_out)
void	crash ()
template<typename t_exception>
void	throw_exception_with_message (const char *p_message)
template<bool p_val>
__static_assert_switcher_t < p_val >::t_assert_failed	static_assert_t ()
template<bool p_val>
__static_assert_switcher_t < p_val >::t_assert_failed	static_assert ()
template<typename t_type>
void	assert_raw_type ()
template<typename t_type>
void	__unsafe__memcpy_t (t_type *p_dst, const t_type *p_src, t_size p_count)
template<typename t_type>
void	__unsafe__in_place_destructor_t (t_type &p_item) throw ()
template<typename t_type>
void	__unsafe__in_place_constructor_t (t_type &p_item)
template<typename t_type>
void	__unsafe__in_place_destructor_array_t (t_type *p_items, t_size p_count) throw ()
template<typename t_type>
t_type *	__unsafe__in_place_constructor_array_t (t_type *p_items, t_size p_count)
template<typename t_type>
t_type *	__unsafe__in_place_resize_array_t (t_type *p_items, t_size p_from, t_size p_to)
template<typename t_type, typename t_copy>
void	__unsafe__in_place_constructor_copy_t (t_type &p_item, const t_copy &p_copyfrom)
template<typename t_type, typename t_copy>
t_type *	__unsafe__in_place_constructor_array_copy_t (t_type *p_items, t_size p_count, const t_copy *p_copyfrom)
template<typename t_type, typename t_copy>
t_type *	__unsafe__in_place_constructor_array_copy_partial_t (t_type *p_items, t_size p_count, const t_copy *p_copyfrom, t_size p_copyfrom_count)
template<typename t_ret, typename t_param>
t_ret	safe_cast (t_param const &p_param)
template<typename t_ret, typename t_param>
t_ret *	safe_ptr_cast (t_param *p_param)
template<typename t_ret, typename t_param>
t_ret	downcast_guarded (const t_param &p_param)
template<typename t_exception, typename t_ret, typename t_param>
t_ret	downcast_guarded_ex (const t_param &p_param)
template<typename t_acc, typename t_add>
void	accumulate_guarded (t_acc &p_acc, const t_add &p_add)
void	bug_check_assert (bool p_condition, const char *p_msg)
void	bug_check_assert (bool p_condition)
void	dynamic_assert (bool p_condition, const char *p_msg)
void	dynamic_assert (bool p_condition)
template<typename T>
void	swap_multi_t (T *p_buffer1, T *p_buffer2, t_size p_size)
template<typename T, t_size p_size>
void	swap_multi_t (T *p_buffer1, T *p_buffer2)
template<t_size p_size>
void	__unsafe__swap_raw_t (void *p_object1, void *p_object2)
template<typename T>
void	swap_t (T &p_item1, T &p_item2)
template<typename t_array>
t_size	array_size_t (const t_array &p_array)
template<typename t_item, t_size p_width>
t_size	array_size_t (const t_item(&p_array)[p_width])
template<typename t_array, typename t_filler>
void	fill_t (t_array &p_buffer, const t_size p_count, const t_filler &p_filler)
template<typename t_array, typename t_filler>
void	fill_ptr_t (t_array *p_buffer, const t_size p_count, const t_filler &p_filler)
template<typename t_item1, typename t_item2>
int	compare_t (const t_item1 &p_item1, const t_item2 &p_item2)
template<typename t_source1, typename t_source2>
t_size	subtract_sorted_lists_calculate_count (const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_destination, typename t_source1, typename t_source2>
void	subtract_sorted_lists (t_destination &p_destination, const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_source1, typename t_source2>
t_size	merge_sorted_lists_calculate_count (const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_destination, typename t_source1, typename t_source2>
void	merge_sorted_lists (t_destination &p_destination, const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_array, typename T>
t_size	append_t (t_array &p_array, const T &p_item)
template<typename t_array, typename T>
t_size	append_swap_t (t_array &p_array, T &p_item)
template<typename t_array, typename T>
t_size	insert_t (t_array &p_array, const T &p_item, t_size p_index)
template<typename t_array, typename T>
t_size	insert_swap_t (t_array &p_array, T &p_item, t_size p_index)
template<typename T>
T	max_t (const T &item1, const T &item2)
template<typename T>
T	min_t (const T &item1, const T &item2)
template<typename T>
T	abs_t (T item)
template<typename T>
T	sqr_t (T item)
template<typename T>
T	clip_t (const T &p_item, const T &p_min, const T &p_max)
template<typename T>
void	delete_t (T *ptr)
template<typename T>
void	delete_array_t (T *ptr)
template<typename T>
T *	clone_t (T *ptr)
template<typename t_exception, typename t_int>
t_int	mul_safe_t (t_int p_val1, t_int p_val2)
template<typename t_src, typename t_dst>
void	memcpy_t (t_dst *p_dst, const t_src *p_src, t_size p_count)
template<typename t_dst, typename t_src>
void	copy_array_loop_t (t_dst &p_dst, const t_src &p_src, t_size p_count)
template<typename t_src, typename t_dst>
void	memcpy_backwards_t (t_dst *p_dst, const t_src *p_src, t_size p_count)
template<typename T, typename t_val>
void	memset_t (T *p_buffer, const t_val &p_val, t_size p_count)
template<typename T, typename t_val>
void	memset_t (T &p_buffer, const t_val &p_val)
template<typename T>
void	memset_null_t (T *p_buffer, t_size p_count)
template<typename T>
void	memset_null_t (T &p_buffer)
template<typename T>
void	memmove_t (T *p_dst, const T *p_src, t_size p_count)
template<typename T>
T *	new_ptr_check_t (T *p_ptr)
template<typename T>
int	sgn_t (const T &p_val)
template<typename T>
const T *	empty_string_t ()
template<>
const char *	empty_string_t< char > ()
template<>
const wchar_t *	empty_string_t< wchar_t > ()
template<typename t_type, typename t_newval>
t_type	replace_t (t_type &p_var, const t_newval &p_newval)
template<typename t_type>
t_type	replace_null_t (t_type &p_var)
template<t_size p_size_pow2>
bool	is_ptr_aligned_t (const void *p_ptr)
template<typename t_array>
void	array_rangecheck_t (const t_array &p_array, t_size p_index)
template<typename t_array>
void	array_rangecheck_t (const t_array &p_array, t_size p_from, t_size p_to)
t_int32	rint32 (double p_val)
t_int64	rint64 (double p_val)
template<typename t_array>
t_size	remove_mask_t (t_array &p_array, const bit_array &p_mask)
template<typename t_array, typename t_compare>
t_size	find_duplicates_sorted_t (t_array p_array, t_size p_count, t_compare p_compare, bit_array_var &p_out)
template<typename t_array, typename t_compare, typename t_permutation>
t_size	find_duplicates_sorted_permutation_t (t_array p_array, t_size p_count, t_compare p_compare, t_permutation const &p_permutation, bit_array_var &p_out)
template<typename t_char>
t_size	strlen_t (const t_char *p_string, t_size p_length=infinite)
template<typename t_list, typename t_array>
void	list_to_array (t_array &p_array, const t_list &p_list)
template<typename t_receiver, typename t_giver>
void	overwrite_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
template<typename t_receiver, typename t_giver>
void	copy_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
template<typename t_object>
rcptr_t< t_object >	rcnew_t ()
template<typename t_object, typename t_param1>
rcptr_t< t_object >	rcnew_t (t_param1 const &p_param1)
template<typename t_object, typename t_param1, typename t_param2>
rcptr_t< t_object >	rcnew_t (t_param1 const &p_param1, t_param2 const &p_param2)
template<typename t_object, typename t_param1, typename t_param2, typename t_param3>
rcptr_t< t_object >	rcnew_t (t_param1 const &p_param1, t_param2 const &p_param2, t_param3 const &p_param3)
template<typename t_object, typename t_param1, typename t_param2, typename t_param3, typename t_param4>
rcptr_t< t_object >	rcnew_t (t_param1 const &p_param1, t_param2 const &p_param2, t_param3 const &p_param3, t_param4 const &p_param4)
template<typename t_object, typename t_param1, typename t_param2, typename t_param3, typename t_param4, typename t_param5>
rcptr_t< t_object >	rcnew_t (t_param1 const &p_param1, t_param2 const &p_param2, t_param3 const &p_param3, t_param4 const &p_param4, t_param5 const &p_param5)
template<typename t_object, typename t_param1, typename t_param2, typename t_param3, typename t_param4, typename t_param5, typename t_param6>
rcptr_t< t_object >	rcnew_t (t_param1 const &p_param1, t_param2 const &p_param2, t_param3 const &p_param3, t_param4 const &p_param4, t_param5 const &p_param5, t_param6 const &p_param6)
PFC_DLL_EXPORT void	swap_void (void *item1, void *item2, t_size width)
PFC_DLL_EXPORT void	reorder_void (void *data, t_size width, const t_size *order, t_size num, void(*swapfunc)(void *item1, void *item2, t_size width)=swap_void)
PFC_DLL_EXPORT void	reorder (reorder_callback &p_callback, const t_size *p_order, t_size p_count)
template<typename t_container>
void	reorder_t (t_container &p_data, const t_size *p_order, t_size p_count)
template<typename t_container>
void	reorder_partial_t (t_container &p_data, t_size p_base, const t_size *p_order, t_size p_count)
template<typename T>
void	reorder_ptr_t (T *p_data, const t_size *p_order, t_size p_count)
PFC_DLL_EXPORT void	sort (sort_callback &p_callback, t_size p_count)
PFC_DLL_EXPORT void	sort_stable (sort_callback &p_callback, t_size p_count)
PFC_DLL_EXPORT void	sort_void_ex (void *base, t_size num, t_size width, int(*comp)(const void *, const void *), void(*swap)(void *, void *, t_size))
PFC_DLL_EXPORT void	sort_void (void *base, t_size num, t_size width, int(*comp)(const void *, const void *))
template<typename t_container, typename t_compare>
static void	sort_t (t_container &p_data, t_compare p_compare, t_size p_count)
template<typename t_container, typename t_compare>
static void	sort_stable_t (t_container &p_data, t_compare p_compare, t_size p_count)
template<typename t_container, typename t_compare, typename t_permutation>
static void	sort_get_permutation_t (const t_container &p_data, t_compare p_compare, t_size p_count, t_permutation const &p_permutation)
template<typename t_container, typename t_compare, typename t_permutation>
static void	sort_stable_get_permutation_t (const t_container &p_data, t_compare p_compare, t_size p_count, t_permutation const &p_permutation)
t_size	scan_filename (const char *ptr)
bool	is_path_separator (unsigned c)
bool	is_path_bad_char (unsigned c)
bool	is_valid_utf8 (const char *param, t_size max=infinite)
bool	is_lower_ascii (const char *param)
bool	is_multiline (const char *p_string, t_size p_len=infinite)
bool	has_path_bad_chars (const char *param)
void	recover_invalid_utf8 (const char *src, char *out, unsigned replace)
void	convert_to_lower_ascii (const char *src, t_size max, char *out, char replace= '?')
char	ascii_tolower (char c)
char	ascii_toupper (char c)
t_size	string_find_first (const char *p_string, char p_tofind, t_size p_start=0)
t_size	string_find_last (const char *p_string, char p_tofind, t_size p_start=~0)
t_size	string_find_first (const char *p_string, const char *p_tofind, t_size p_start=0)
t_size	string_find_last (const char *p_string, const char *p_tofind, t_size p_start=~0)
t_size	string_find_first_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start=0)
t_size	string_find_last_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start=~0)
t_size	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=0)
t_size	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=~0)
template<typename t_char>
t_size	strlen_max_t (const t_char *ptr, t_size max)
t_size	strlen_max (const char *ptr, t_size max)
t_size	wcslen_max (const wchar_t *ptr, t_size max)
bool	string_is_numeric (const char *p_string, t_size p_length=infinite)
bool	char_is_numeric (char p_char)
bool	char_is_ascii_alpha_upper (char p_char)
bool	char_is_ascii_alpha_lower (char p_char)
bool	char_is_ascii_alpha (char p_char)
bool	char_is_ascii_alphanumeric (char p_char)
unsigned	atoui_ex (const char *ptr, t_size max)
t_int64	atoi64_ex (const char *ptr, t_size max)
t_uint64	atoui64_ex (const char *ptr, t_size max)
t_size	strlen_utf8 (const char *s, t_size num=~0)
t_size	utf8_char_len (const char *s, t_size max=~0)
t_size	utf8_char_len_from_header (char c)
t_size	utf8_chars_to_bytes (const char *string, t_size count)
t_size	strcpy_utf8_truncate (const char *src, char *out, t_size maxbytes)
t_size	utf8_decode_char (const char *src, unsigned *out, t_size src_bytes=~0)
t_size	utf8_encode_char (unsigned c, char *out)
t_size	utf16_decode_char (const wchar_t *p_source, unsigned *p_out, t_size p_source_length=~0)
t_size	utf16_encode_char (unsigned c, wchar_t *out)
t_size	strstr_ex (const char *p_string, t_size p_string_len, const char *p_substring, t_size p_substring_len)
int	strcmp_partial (const char *p_string, const char *p_substring)
int	strcmp_partial_ex (const char *p_string, t_size p_string_length, const char *p_substring, t_size p_substring_length)
t_size	skip_utf8_chars (const char *ptr, t_size count)
char *	strdup_n (const char *src, t_size len)
int	stricmp_ascii (const char *s1, const char *s2)
int	stricmp_ascii_ex (const char *s1, t_size len1, const char *s2, t_size len2)
int	strcmp_ex (const char *p1, t_size n1, const char *p2, t_size n2)
unsigned	utf8_get_char (const char *src)
bool	utf8_advance (const char *&var)
bool	utf8_advance (char *&var)
const char *	utf8_char_next (const char *src)
char *	utf8_char_next (char *src)
class	PFC_DEPRECATE ("Use string8/string_fixed_t with operator<< overloads instead.") string_printf
void	float_to_string (char *out, t_size out_max, double val, unsigned precision, bool force_sign=false)
double	string_to_float (const char *src, t_size len=infinite)
template<>
void	swap_t (string8 &p_item1, string8 &p_item2)
Variables
const GUID	guid_null

---

Typedef Documentation

typedef vartoggle_t<bool> pfc::booltoggle

typedef std::exception pfc::exception

typedef ptr_list_t<void> pfc::ptr_list

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 list_base_const_t<const char*> pfc::string_list_const

typedef string_simple_t<char> pfc::string_simple

---

Enumeration Type Documentation

anonymous enum

Enumerator:

byte_order_is_big_endian
byte_order_is_little_endian

---

Function Documentation

template<typename T>

void pfc::__raw_free_t

(

T *

p_block

)

throw () [inline]

template<typename T>

T* pfc::__raw_malloc_t

(

t_size

p_size

)

[inline]

template<typename T>

bool pfc::__raw_realloc_inplace_t	(	T *	p_block,
		t_size	p_size
	)			[inline]

template<typename T>

T* pfc::__raw_realloc_t	(	T *	p_block,
		t_size	p_size
	)			[inline]

template<typename t_type, typename t_copy>

t_type* pfc::__unsafe__in_place_constructor_array_copy_partial_t	(	t_type *	p_items,
		t_size	p_count,
		const t_copy *	p_copyfrom,
		t_size	p_copyfrom_count
	)			[inline]

template<typename t_type, typename t_copy>

t_type* pfc::__unsafe__in_place_constructor_array_copy_t	(	t_type *	p_items,
		t_size	p_count,
		const t_copy *	p_copyfrom
	)			[inline]

template<typename t_type>

t_type* pfc::__unsafe__in_place_constructor_array_t	(	t_type *	p_items,
		t_size	p_count
	)			[inline]

template<typename t_type, typename t_copy>

void pfc::__unsafe__in_place_constructor_copy_t	(	t_type &	p_item,
		const t_copy &	p_copyfrom
	)			[inline]

template<typename t_type>

void pfc::__unsafe__in_place_constructor_t

(

t_type &

p_item

)

[inline]

template<typename t_type>

void pfc::__unsafe__in_place_destructor_array_t	(	t_type *	p_items,
		t_size	p_count
	)			throw () [inline]

template<typename t_type>

void pfc::__unsafe__in_place_destructor_t

(

t_type &

p_item

)

throw () [inline]

template<typename t_type>

t_type* pfc::__unsafe__in_place_resize_array_t	(	t_type *	p_items,
		t_size	p_from,
		t_size	p_to
	)			[inline]

template<typename t_type>

void pfc::__unsafe__memcpy_t	(	t_type *	p_dst,
		const t_type *	p_src,
		t_size	p_count
	)			[inline]

template<t_size p_size>

void pfc::__unsafe__swap_raw_t	(	void *	p_object1,
		void *	p_object2
	)			[inline]

template<typename T>

T pfc::abs_t

(

T

item

)

[inline]

template<typename t_acc, typename t_add>

void pfc::accumulate_guarded	(	t_acc &	p_acc,
		const t_add &	p_add
	)			[inline]

template<typename t_array, typename T>

t_size pfc::append_swap_t	(	t_array &	p_array,
		T &	p_item
	)			[inline]

template<typename t_array, typename T>

t_size pfc::append_t	(	t_array &	p_array,
		const T &	p_item
	)			[inline]

template<typename t_array>

void pfc::array_rangecheck_t	(	const t_array &	p_array,
		t_size	p_from,
		t_size	p_to
	)			[inline]

template<typename t_array>

void pfc::array_rangecheck_t	(	const t_array &	p_array,
		t_size	p_index
	)			[inline]

template<typename t_item, t_size p_width>

t_size pfc::array_size_t

(

const t_item(&)

p_array[p_width]

)

[inline]

template<typename t_array>

t_size pfc::array_size_t

(

const t_array &

p_array

)

[inline]

char pfc::ascii_tolower

(

char

c

)

[inline]

char pfc::ascii_toupper

(

char

c

)

[inline]

template<typename t_type>

void pfc::assert_raw_type

(

)

[inline]

t_int64 pfc::atoi64_ex	(	const char *	ptr,
		t_size	max
	)

t_uint64 pfc::atoui64_ex	(	const char *	ptr,
		t_size	max
	)

unsigned pfc::atoui_ex	(	const char *	ptr,
		t_size	max
	)

PFC_DLL_EXPORT bool pfc::bsearch	(	t_size	p_count,
		bsearch_callback const &	p_callback,
		t_size &	p_result
	)

template<typename t_callback>

bool pfc::bsearch_inline_t	(	t_size	p_count,
		const t_callback &	p_callback,
		t_size &	p_result
	)			[inline]

template<typename t_container, typename t_compare, typename t_param, typename t_permutation>

bool pfc::bsearch_permutation_t	(	t_size	p_count,
		const t_container &	p_container,
		t_compare	p_compare,
		const t_param &	p_param,
		const t_permutation &	p_permutation,
		t_size &	p_index
	)			[inline]

template<typename t_container, typename t_compare, typename t_param>

bool pfc::bsearch_range_t	(	const t_size	p_count,
		const t_container &	p_container,
		t_compare	p_compare,
		const t_param &	p_param,
		t_size &	p_range_base,
		t_size &	p_range_count
	)			[inline]

template<typename t_buffer, typename t_value>

bool pfc::bsearch_simple_inline_t	(	const t_buffer &	p_buffer,
		t_size	p_count,
		t_value const &	p_value,
		t_size &	p_result
	)			[inline]

template<typename t_container, typename t_compare, typename t_param>

bool pfc::bsearch_t	(	t_size	p_count,
		const t_container &	p_container,
		t_compare	p_compare,
		const t_param &	p_param,
		t_size &	p_index
	)			[inline]

void pfc::bug_check_assert

(

bool

p_condition

)

[inline]

void pfc::bug_check_assert	(	bool	p_condition,
		const char *	p_msg
	)			[inline]

template<typename T>

T pfc::byteswap_if_be_t

(

T

p_param

)

[inline]

template<typename T>

T pfc::byteswap_if_le_t

(

T

p_param

)

[inline]

void pfc::byteswap_raw	(	void *	p_buffer,
		t_size	p_bytes
	)

template<typename T>

T pfc::byteswap_t

(

T

p_source

)

[inline]

template<>

char pfc::byteswap_t< char >

(

char

p_source

)

[inline]

template<>

double pfc::byteswap_t< double >

(

double

p_source

)

[inline]

template<>

float pfc::byteswap_t< float >

(

float

p_source

)

[inline]

template<>

GUID pfc::byteswap_t< GUID >

(

GUID

p_guid

)

[inline]

template<>

t_int16 pfc::byteswap_t< t_int16 >

(

t_int16

p_source

)

[inline]

template<>

t_int32 pfc::byteswap_t< t_int32 >

(

t_int32

p_source

)

[inline]

template<>

t_int64 pfc::byteswap_t< t_int64 >

(

t_int64

p_source

)

[inline]

template<>

t_uint16 pfc::byteswap_t< t_uint16 >

(

t_uint16

p_source

)

[inline]

template<>

t_uint32 pfc::byteswap_t< t_uint32 >

(

t_uint32

p_source

)

[inline]

template<>

t_uint64 pfc::byteswap_t< t_uint64 >

(

t_uint64

p_source

)

[inline]

template<>

unsigned char pfc::byteswap_t< unsigned char >

(

unsigned char

p_source

)

[inline]

template<>

wchar_t pfc::byteswap_t< wchar_t >

(

wchar_t

p_source

)

[inline]

template<typename T>

t_size pfc::calc_array_width

(

t_size

p_width

)

[inline]

bool pfc::char_is_ascii_alpha

(

char

p_char

)

[inline]

bool pfc::char_is_ascii_alpha_lower

(

char

p_char

)

[inline]

bool pfc::char_is_ascii_alpha_upper

(

char

p_char

)

[inline]

bool pfc::char_is_ascii_alphanumeric

(

char

p_char

)

[inline]

bool pfc::char_is_numeric

(

char

p_char

)

[inline]

template<typename T>

T pfc::clip_t	(	const T &	p_item,
		const T &	p_min,
		const T &	p_max
	)			[inline]

template<typename T>

T* pfc::clone_t

(

T *

ptr

)

[inline]

template<typename t_item1, typename t_item2>

int pfc::compare_t	(	const t_item1 &	p_item1,
		const t_item2 &	p_item2
	)			[inline]

template<>

int pfc::compare_t< GUID, GUID >	(	const GUID &	p_item1,
		const GUID &	p_item2
	)			[inline]

void pfc::convert_to_lower_ascii	(	const char *	src,
		t_size	max,
		char *	out,
		char	replace = '?'
	)

template<typename t_dst, typename t_src>

void pfc::copy_array_loop_t	(	t_dst &	p_dst,
		const t_src &	p_src,
		t_size	p_count
	)			[inline]

template<typename t_to, typename t_from>

void pfc::copy_array_t	(	t_to &	p_to,
		const t_from &	p_from
	)			[inline]

template<typename t_receiver, typename t_giver>

void pfc::copy_list_enumerated	(	t_receiver &	p_receiver,
		const t_giver &	p_giver
	)			[inline]

void pfc::crash

(

)

template<typename TInt>

TInt pfc::decode_big_endian

(

const t_uint8 *

p_buffer

)

[inline]

template<typename TInt>

void pfc::decode_big_endian	(	TInt &	p_out,
		const t_uint8 *	p_buffer
	)			[inline]

template<typename TInt>

TInt pfc::decode_little_endian

(

const t_uint8 *

p_buffer

)

[inline]

template<typename TInt>

void pfc::decode_little_endian	(	TInt &	p_out,
		const t_uint8 *	p_buffer
	)			[inline]

template<typename T>

void pfc::delete_array_t

(

T *

ptr

)

[inline]

template<typename T>

void pfc::delete_t

(

T *

ptr

)

[inline]

template<typename t_ret, typename t_param>

t_ret pfc::downcast_guarded

(

const t_param &

p_param

)

[inline]

template<typename t_exception, typename t_ret, typename t_param>

t_ret pfc::downcast_guarded_ex

(

const t_param &

p_param

)

[inline]

void pfc::dynamic_assert

(

bool

p_condition

)

[inline]

void pfc::dynamic_assert	(	bool	p_condition,
		const char *	p_msg
	)			[inline]

template<typename T>

const T* pfc::empty_string_t

(

)

[inline]

template<>

const char* pfc::empty_string_t< char >

(

)

[inline]

template<>

const wchar_t* pfc::empty_string_t< wchar_t >

(

)

[inline]

template<typename TInt>

void pfc::encode_big_endian	(	t_uint8 *	p_buffer,
		TInt	p_value
	)			[inline]

template<typename TInt>

void pfc::encode_little_endian	(	t_uint8 *	p_buffer,
		TInt	p_value
	)			[inline]

template<typename t_array, typename t_value>

void pfc::fill_array_t	(	t_array &	p_array,
		const t_value &	p_value
	)			[inline]

template<typename t_array, typename t_filler>

void pfc::fill_ptr_t	(	t_array *	p_buffer,
		const t_size	p_count,
		const t_filler &	p_filler
	)			[inline]

template<typename t_array, typename t_filler>

void pfc::fill_t	(	t_array &	p_buffer,
		const t_size	p_count,
		const t_filler &	p_filler
	)			[inline]

template<typename t_array, typename t_compare, typename t_permutation>

t_size pfc::find_duplicates_sorted_permutation_t	(	t_array	p_array,
		t_size	p_count,
		t_compare	p_compare,
		t_permutation const &	p_permutation,
		bit_array_var &	p_out
	)			[inline]

template<typename t_array, typename t_compare>

t_size pfc::find_duplicates_sorted_t	(	t_array	p_array,
		t_size	p_count,
		t_compare	p_compare,
		bit_array_var &	p_out
	)			[inline]

void pfc::float_to_string	(	char *	out,
		t_size	out_max,
		double	val,
		unsigned	precision,
		bool	force_sign = false
	)

int pfc::guid_compare	(	const GUID &	g1,
		const GUID &	g2
	)			[inline]

bool pfc::guid_equal	(	const GUID &	g1,
		const GUID &	g2
	)			[inline]

bool pfc::has_path_bad_chars

(

const char *

param

)

template<typename t_array, typename T>

t_size pfc::insert_swap_t	(	t_array &	p_array,
		T &	p_item,
		t_size	p_index
	)			[inline]

template<typename t_array, typename T>

t_size pfc::insert_t	(	t_array &	p_array,
		const T &	p_item,
		t_size	p_index
	)			[inline]

bool pfc::is_lower_ascii

(

const char *

param

)

bool pfc::is_multiline	(	const char *	p_string,
		t_size	p_len = infinite
	)

bool pfc::is_path_bad_char

(

unsigned

c

)

bool pfc::is_path_separator

(

unsigned

c

)

template<typename t_item>

bool pfc::is_pointer_in_range	(	const t_item *	p_buffer,
		t_size	p_buffer_size,
		const void *	p_pointer
	)			[inline]

template<t_size p_size_pow2>

bool pfc::is_ptr_aligned_t

(

const void *

p_ptr

)

[inline]

bool pfc::is_valid_utf8	(	const char *	param,
		t_size	max = infinite
	)

template<typename t_list, typename t_array>

void pfc::list_to_array	(	t_array &	p_array,
		const t_list &	p_list
	)			[inline]

template<typename T>

T pfc::max_t	(	const T &	item1,
		const T &	item2
	)			[inline]

template<typename t_src, typename t_dst>

void pfc::memcpy_backwards_t	(	t_dst *	p_dst,
		const t_src *	p_src,
		t_size	p_count
	)			[inline]

template<typename t_src, typename t_dst>

void pfc::memcpy_t	(	t_dst *	p_dst,
		const t_src *	p_src,
		t_size	p_count
	)			[inline]

template<typename T>

void pfc::memmove_t	(	T *	p_dst,
		const T *	p_src,
		t_size	p_count
	)			[inline]

template<typename T>

void pfc::memset_null_t

(

T &

p_buffer

)

[inline]

template<typename T>

void pfc::memset_null_t	(	T *	p_buffer,
		t_size	p_count
	)			[inline]

template<typename T, typename t_val>

void pfc::memset_t	(	T &	p_buffer,
		const t_val &	p_val
	)			[inline]

template<typename T, typename t_val>

void pfc::memset_t	(	T *	p_buffer,
		const t_val &	p_val,
		t_size	p_count
	)			[inline]

template<typename t_destination, typename t_source1, typename t_source2>

void pfc::merge_sorted_lists	(	t_destination &	p_destination,
		const t_source1 &	p_source1,
		const t_source2 &	p_source2
	)			[inline]

Merges p_source1 and p_source2, storing content in p_destination. Both source lists must be sorted. Note: duplicates will be carried over.

template<typename t_source1, typename t_source2>

t_size pfc::merge_sorted_lists_calculate_count	(	const t_source1 &	p_source1,
		const t_source2 &	p_source2
	)			[inline]

template<typename T>

T pfc::min_t	(	const T &	item1,
		const T &	item2
	)			[inline]

template<typename t_exception, typename t_int>

t_int pfc::mul_safe_t	(	t_int	p_val1,
		t_int	p_val2
	)			[inline]

template<typename T>

T* pfc::new_ptr_check_t

(

T *

p_ptr

)

[inline]

template<typename t_receiver, typename t_giver>

void pfc::overwrite_list_enumerated	(	t_receiver &	p_receiver,
		const t_giver &	p_giver
	)			[inline]

class pfc::PFC_DEPRECATE

(

"Use string8/string_fixed_t with operator<< overloads instead."

)

PFC_DLL_EXPORT void pfc::print_hex_raw	(	const void *	buffer,
		unsigned	bytes,
		char *	p_out
	)

static void pfc::raw_free

(

void *

p_block

)

throw () [static]

static void* pfc::raw_malloc

(

t_size

p_size

)

[static]

static void* pfc::raw_realloc	(	void *	p_ptr,
		t_size	p_size
	)			[static]

static bool pfc::raw_realloc_inplace	(	void *	p_block,
		t_size	p_size
	)			throw () [static]

template<typename t_object, typename t_param1, typename t_param2, typename t_param3, typename t_param4, typename t_param5, typename t_param6>

rcptr_t<t_object> pfc::rcnew_t	(	t_param1 const &	p_param1,
		t_param2 const &	p_param2,
		t_param3 const &	p_param3,
		t_param4 const &	p_param4,
		t_param5 const &	p_param5,
		t_param6 const &	p_param6
	)			[inline]

template<typename t_object, typename t_param1, typename t_param2, typename t_param3, typename t_param4, typename t_param5>

rcptr_t<t_object> pfc::rcnew_t	(	t_param1 const &	p_param1,
		t_param2 const &	p_param2,
		t_param3 const &	p_param3,
		t_param4 const &	p_param4,
		t_param5 const &	p_param5
	)			[inline]

template<typename t_object, typename t_param1, typename t_param2, typename t_param3, typename t_param4>

rcptr_t<t_object> pfc::rcnew_t	(	t_param1 const &	p_param1,
		t_param2 const &	p_param2,
		t_param3 const &	p_param3,
		t_param4 const &	p_param4
	)			[inline]

template<typename t_object, typename t_param1, typename t_param2, typename t_param3>

rcptr_t<t_object> pfc::rcnew_t	(	t_param1 const &	p_param1,
		t_param2 const &	p_param2,
		t_param3 const &	p_param3
	)			[inline]

template<typename t_object, typename t_param1, typename t_param2>

rcptr_t<t_object> pfc::rcnew_t	(	t_param1 const &	p_param1,
		t_param2 const &	p_param2
	)			[inline]

template<typename t_object, typename t_param1>

rcptr_t<t_object> pfc::rcnew_t

(

t_param1 const &

p_param1

)

[inline]

template<typename t_object>

rcptr_t<t_object> pfc::rcnew_t

(

)

[inline]

void pfc::recover_invalid_utf8	(	const char *	src,
		char *	out,
		unsigned	replace
	)

template<typename t_array>

t_size pfc::remove_mask_t	(	t_array &	p_array,
		const bit_array &	p_mask
	)			[inline]

PFC_DLL_EXPORT void pfc::reorder	(	reorder_callback &	p_callback,
		const t_size *	p_order,
		t_size	p_count
	)

template<typename t_container>

void pfc::reorder_partial_t	(	t_container &	p_data,
		t_size	p_base,
		const t_size *	p_order,
		t_size	p_count
	)			[inline]

template<typename T>

void pfc::reorder_ptr_t	(	T *	p_data,
		const t_size *	p_order,
		t_size	p_count
	)			[inline]

template<typename t_container>

void pfc::reorder_t	(	t_container &	p_data,
		const t_size *	p_order,
		t_size	p_count
	)			[inline]

PFC_DLL_EXPORT void pfc::reorder_void	(	void *	data,
		t_size	width,
		const t_size *	order,
		t_size	num,
		void(*)(void *item1, void *item2, t_size width)	swapfunc = swap_void
	)

template<typename t_type>

t_type pfc::replace_null_t

(

t_type &

p_var

)

[inline]

template<typename t_type, typename t_newval>

t_type pfc::replace_t	(	t_type &	p_var,
		const t_newval &	p_newval
	)			[inline]

t_int32 pfc::rint32

(

double

p_val

)

[inline]

t_int64 pfc::rint64

(

double

p_val

)

[inline]

template<typename t_ret, typename t_param>

t_ret pfc::safe_cast

(

t_param const &

p_param

)

[inline]

template<typename t_ret, typename t_param>

t_ret* pfc::safe_ptr_cast

(

t_param *

p_param

)

[inline]

template<typename t_exception, typename t_int>

t_int pfc::safe_shift_left_t	(	t_int	p_val,
		t_size	p_shift = 1
	)			[inline]

t_size pfc::scan_filename

(

const char *

ptr

)

template<typename T>

int pfc::sgn_t

(

const T &

p_val

)

[inline]

t_size pfc::skip_utf8_chars	(	const char *	ptr,
		t_size	count
	)

PFC_DLL_EXPORT void pfc::sort	(	sort_callback &	p_callback,
		t_size	p_count
	)

template<typename t_container, typename t_compare, typename t_permutation>

static void pfc::sort_get_permutation_t	(	const t_container &	p_data,
		t_compare	p_compare,
		t_size	p_count,
		t_permutation const &	p_permutation
	)			[inline, static]

PFC_DLL_EXPORT void pfc::sort_stable	(	sort_callback &	p_callback,
		t_size	p_count
	)

template<typename t_container, typename t_compare, typename t_permutation>

static void pfc::sort_stable_get_permutation_t	(	const t_container &	p_data,
		t_compare	p_compare,
		t_size	p_count,
		t_permutation const &	p_permutation
	)			[inline, static]

template<typename t_container, typename t_compare>

static void pfc::sort_stable_t	(	t_container &	p_data,
		t_compare	p_compare,
		t_size	p_count
	)			[inline, static]

template<typename t_container, typename t_compare>

static void pfc::sort_t	(	t_container &	p_data,
		t_compare	p_compare,
		t_size	p_count
	)			[inline, static]

PFC_DLL_EXPORT void pfc::sort_void	(	void *	base,
		t_size	num,
		t_size	width,
		int(*)(const void *, const void *)	comp
	)

PFC_DLL_EXPORT void pfc::sort_void_ex	(	void *	base,
		t_size	num,
		t_size	width,
		int(*)(const void *, const void *)	comp,
		void(*)(void *, void *, t_size)	swap
	)

template<typename T>

T pfc::sqr_t

(

T

item

)

[inline]

template<bool p_val>

__static_assert_switcher_t<p_val>::t_assert_failed pfc::static_assert

(

)

[inline]

template<bool p_val>

__static_assert_switcher_t<p_val>::t_assert_failed pfc::static_assert_t

(

)

[inline]

int pfc::strcmp_ex	(	const char *	p1,
		t_size	n1,
		const char *	p2,
		t_size	n2
	)

int pfc::strcmp_partial	(	const char *	p_string,
		const char *	p_substring
	)

int pfc::strcmp_partial_ex	(	const char *	p_string,
		t_size	p_string_length,
		const char *	p_substring,
		t_size	p_substring_length
	)

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
	)

int pfc::stricmp_ascii_ex	(	const char *	s1,
		t_size	len1,
		const char *	s2,
		t_size	len2
	)

t_size pfc::string_find_first	(	const char *	p_string,
		const char *	p_tofind,
		t_size	p_start = 0
	)

t_size pfc::string_find_first	(	const char *	p_string,
		char	p_tofind,
		t_size	p_start = 0
	)

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 = 0
	)

t_size pfc::string_find_first_ex	(	const char *	p_string,
		t_size	p_string_length,
		char	p_tofind,
		t_size	p_start = 0
	)

t_size pfc::string_find_last	(	const char *	p_string,
		const char *	p_tofind,
		t_size	p_start = ~0
	)

t_size pfc::string_find_last	(	const char *	p_string,
		char	p_tofind,
		t_size	p_start = ~0
	)

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 = ~0
	)

t_size pfc::string_find_last_ex	(	const char *	p_string,
		t_size	p_string_length,
		char	p_tofind,
		t_size	p_start = ~0
	)

bool pfc::string_is_numeric	(	const char *	p_string,
		t_size	p_length = infinite
	)

double pfc::string_to_float	(	const char *	src,
		t_size	len = infinite
	)

t_size pfc::strlen_max	(	const char *	ptr,
		t_size	max
	)			[inline]

template<typename t_char>

t_size pfc::strlen_max_t	(	const t_char *	ptr,
		t_size	max
	)			[inline]

template<typename t_char>

t_size pfc::strlen_t	(	const t_char *	p_string,
		t_size	p_length = infinite
	)			[inline]

t_size pfc::strlen_utf8	(	const char *	s,
		t_size	num = ~0
	)

t_size pfc::strstr_ex	(	const char *	p_string,
		t_size	p_string_len,
		const char *	p_substring,
		t_size	p_substring_len
	)

template<typename t_destination, typename t_source1, typename t_source2>

void pfc::subtract_sorted_lists	(	t_destination &	p_destination,
		const t_source1 &	p_source1,
		const t_source2 &	p_source2
	)			[inline]

Subtracts p_source2 contents from p_source1 and stores result in p_destination. Both source lists must be sorted. Note: duplicates will be carried over (and ignored for p_source2).

template<typename t_source1, typename t_source2>

t_size pfc::subtract_sorted_lists_calculate_count	(	const t_source1 &	p_source1,
		const t_source2 &	p_source2
	)			[inline]

template<typename T, t_size p_size>

void pfc::swap_multi_t	(	T *	p_buffer1,
		T *	p_buffer2
	)			[inline]

template<typename T>

void pfc::swap_multi_t	(	T *	p_buffer1,
		T *	p_buffer2,
		t_size	p_size
	)			[inline]

template<>

void pfc::swap_t	(	string8 &	p_item1,
		string8 &	p_item2
	)			[inline]

template<typename T>

void pfc::swap_t	(	T &	p_item1,
		T &	p_item2
	)			[inline]

PFC_DLL_EXPORT void pfc::swap_void	(	void *	item1,
		void *	item2,
		t_size	width
	)

template<typename t_exception>

void pfc::throw_exception_with_message

(

const char *

p_message

)

[inline]

t_size pfc::utf16_decode_char	(	const wchar_t *	p_source,
		unsigned *	p_out,
		t_size	p_source_length = ~0
	)

t_size pfc::utf16_encode_char	(	unsigned	c,
		wchar_t *	out
	)

bool pfc::utf8_advance

(

char *&

var

)

[inline]

bool pfc::utf8_advance

(

const char *&

var

)

[inline]

t_size pfc::utf8_char_len	(	const char *	s,
		t_size	max = ~0
	)

t_size pfc::utf8_char_len_from_header

(

char

c

)

char* pfc::utf8_char_next

(

char *

src

)

[inline]

const char* pfc::utf8_char_next

(

const char *

src

)

[inline]

t_size pfc::utf8_chars_to_bytes	(	const char *	string,
		t_size	count
	)

t_size pfc::utf8_decode_char	(	const char *	src,
		unsigned *	out,
		t_size	src_bytes = ~0
	)

t_size pfc::utf8_encode_char	(	unsigned	c,
		char *	out
	)

unsigned pfc::utf8_get_char

(

const char *

src

)

t_size pfc::wcslen_max	(	const wchar_t *	ptr,
		t_size	max
	)			[inline]

---

Variable Documentation

const GUID pfc::guid_null