pfc Namespace Reference

Namespaces
	io
	stringcvt

Data Structures
class	__array_fast_helper_t
class	__array_lite_helper_t
class	__chain_list_elem
class	__chain_list_iterator_traits
class	__DecodeIntHelper
class	__DecodeIntHelper< TInt, 0, IsBigEndian >
class	__DecodeIntHelper< TInt, 1, IsBigEndian >
class	__EncodeIntHelper
class	__EncodeIntHelper< TInt, 0, IsBigEndian >
class	__EncodeIntHelper< TInt, 1, IsBigEndian >
class	__exception_with_message_t
class	__list_to_array_enumerator
class	__map_overwrite_wrapper
class	__splitStringSimple_arrayWrapper
class	__splitStringSimple_calculateSubstringCount
class	__splitStringSimple_listWrapper
class	__stringEmpty
class	_avltree_node
class	_list_node
class	_readWriteLock_scope_read
class	_readWriteLock_scope_write
class	_splitStringSimple_check
class	_splitStringSimple_check< char >
class	_splitStringSimple_check< const char * >
class	alloc_dummy
class	alloc_fast
class	alloc_fast_aggressive
class	alloc_fixed
class	alloc_hybrid
class	alloc_simple
class	alloc_standard
class	array_2d_t
class	array_hybrid_t
class	array_staticsize_t
class	array_t
class	assert_byte_type
class	assert_byte_type< char >
class	assert_byte_type< signed char >
class	assert_byte_type< unsigned char >
class	assert_same_type
class	assert_same_type< p_type, p_type >
class	avltree_t
class	bigmem
class	binarySearch
class	bit_array
class	bit_array_flatIndexList
class	bit_array_var
class	bit_array_var_impl
class	bsearch_callback
class	bsearch_callback_impl_permutation_t
class	bsearch_callback_impl_simple_t
class	chain_list_v2_t
class	com_ptr_t
class	combine_traits
class	comparator_array
class	comparator_default
class	comparator_dual
class	comparator_list
class	comparator_memcmp
class	comparator_naturalSort
class	comparator_pointer
class	comparator_strcmp
class	comparator_stricmp_ascii
class	const_iterator
class	counter
class	enumerator_add_item
class	event
class	exception_nix
class	fdSelect
class	fdSet
class	fileHandle
class	format_array
class	format_char
class	format_file_size_short
class	format_fixedpoint
class	format_float
class	format_guid_cpp
class	format_hex
class	format_hex_lowercase
class	format_hexdump
class	format_hexdump_ex
class	format_hexdump_lowercase
class	format_int
class	format_pad_left
class	format_pad_right
class	format_time
class	format_time_ex
class	format_uint
class	hires_timer
class	incrementScope
class	instance_tracker_client_t
class	instance_tracker_server_t
class	instanceTracker
class	instanceTrackerV2
class	int_container_helper
class	int_specs_signed_t
class	int_specs_t
class	int_specs_t< char >
class	int_specs_t< int >
class	int_specs_t< long >
class	int_specs_t< long long >
class	int_specs_t< short >
class	int_specs_t< unsigned char >
class	int_specs_t< unsigned int >
class	int_specs_t< unsigned long >
class	int_specs_t< unsigned long long >
class	int_specs_t< unsigned short >
class	int_specs_t< wchar_t >
class	int_specs_unsigned_t
class	is_same_type
class	is_same_type< p_type, p_type >
class	iterator
class	list_base_const_t
class	list_base_t
class	list_const_array_ref_t
class	list_const_array_t
class	list_const_cast_t
class	list_const_permutation_t
class	list_const_ptr_t
class	list_hybrid_t
class	list_impl_t
class	list_partial_ref_t
class	list_permutation_t
class	list_single_ref_t
class	list_t
class	lores_timer
class	map_t
class	mem_block_aligned
class	mem_block_aligned_incremental_t
class	mem_block_aligned_t
class	mutex
class	mutexAttr
class	mutexBase
class	mutexRecur
class	mutexRecurStatic
class	mutexScope
class	nix_event
class	objDestructNotify
struct	objDestructNotifyData
class	objDestructNotifyScope
class	print_guid
class	profiler_local
class	profiler_static
class	ptr_list_const_array_t
class	ptr_list_const_cast_t
class	ptr_list_hybrid_t
class	ptr_list_t
class	ptrholder_t
class	ptrholder_t< void, t_releaser >
class	rc_container_base
class	rc_container_t
class	rcptr_t
class	readWriteLock
class	readWriteLockAttr
class	readWriteLockBase
class	refcounted_object_ptr_t
class	refcounted_object_root
class	releaser_delete
class	releaser_delete_array
class	releaser_free
class	reorder_callback
class	reorder_callback_impl_delta
class	reorder_callback_impl_ptr_t
class	reorder_callback_impl_t
class	sized_int_t
class	sized_int_t< 1 >
class	sized_int_t< 2 >
class	sized_int_t< 4 >
class	sized_int_t< 8 >
class	sort_callback
class	sort_callback_impl_auto_wrap_t
class	sort_callback_impl_permutation_wrap_t
class	sort_callback_impl_simple_wrap_t
class	sort_callback_stabilizer
class	static_assert_t
class	static_assert_t< true >
class	string
class	string8_t
class	string_base
class	string_base_ref
class	string_buffer
class	string_directory
class	string_extension
class	string_filename
class	string_filename_ext
class	string_fixed_t
class	string_list_impl
struct	string_part_ref
class	string_printf
class	string_printf_va
class	string_receiver
class	string_replace_extension
class	string_simple_t
class	stringp
class	syncd_storage
class	syncd_storage_flagged
class	thread
class	traits_combined
class	traits_default
class	traits_default_movable
class	traits_rawobject
class	traits_rcptr
class	traits_service_ptr
class	traits_t
class	traits_t< __array_fast_helper_t< t_item > >
class	traits_t< alloc_fast< t_item > >
class	traits_t< alloc_fast_aggressive< t_item > >
class	traits_t< alloc_simple< t_item > >
class	traits_t< alloc_standard< t_item > >
class	traits_t< array_staticsize_t< t_item > >
class	traits_t< array_t< t_item, t_alloc > >
class	traits_t< avltree_t< t_storage, t_comparator > >
class	traits_t< bool >
class	traits_t< chain_list_v2_t< t_item > >
class	traits_t< char >
class	traits_t< const_iterator< t_item > >
class	traits_t< double >
class	traits_t< file_info_impl_utils::info_entry >
class	traits_t< file_info_impl_utils::meta_entry >
class	traits_t< float >
class	traits_t< GUID >
class	traits_t< hasher_md5_result >
class	traits_t< hasher_md5_state >
class	traits_t< int >
class	traits_t< iterator< t_item > >
class	traits_t< list_t< item, alloc > >
class	traits_t< long >
class	traits_t< long long >
class	traits_t< ptr_list_t< item, base > >
class	traits_t< rcptr_t< T > >
class	traits_t< refcounted_object_ptr_t< T > >
class	traits_t< service_nnptr_t< T > >
class	traits_t< service_ptr_t< T > >
class	traits_t< short >
class	traits_t< signed char >
class	traits_t< string >
class	traits_t< string8_t< t_alloc > >
class	traits_t< string_simple_t< t_char > >
class	traits_t< T * >
class	traits_t< T[p_count]>
class	traits_t< typename alloc_fixed< p_width >::template alloc< t_item > >
class	traits_t< typename alloc_hybrid< p_width, t_alloc >::template alloc< t_item > >
class	traits_t< unsigned char >
class	traits_t< unsigned int >
class	traits_t< unsigned long >
class	traits_t< unsigned long long >
class	traits_t< unsigned short >
class	traits_t< wchar_t >
class	traits_vtable
class	vartoggle_t

Typedefs
typedef vartoggle_t< bool >	booltoggle
typedef nix_event	event
typedef HANDLE	eventHandle_t
typedef std::exception	exception
typedef HANDLE	fileHandle_t
typedef hires_timer	lores_timer
typedef ptr_list_t< void >	ptr_list
typedef counter	refcounter
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 list_base_const_t< const char * >	string_list_const
typedef string_simple_t< char >	string_simple
typedef _rcptr_null *	t_rcptr_null

Enumerations
enum	{   CPU_HAVE_3DNOW = 1 << 0, CPU_HAVE_3DNOW_EX = 1 << 1, CPU_HAVE_SSE = 1 << 2, CPU_HAVE_SSE2 = 1 << 3,   CPU_HAVE_SSE3 = 1 << 4, CPU_HAVE_SSSE3 = 1 << 5, CPU_HAVE_SSE41 = 1 << 6, CPU_HAVE_SSE42 = 1 << 7 }

Functions
static t_size	__pivot_helper (pfc::sort_callback &p_callback, t_size const p_base, t_size const p_count)
template<typename T >
void	__raw_free_t (T *p_block) throw ()
template<typename T >
T *	__raw_malloc_t (t_size p_size)
template<typename T >
bool	__raw_realloc_inplace_t (T *p_block, t_size p_size)
template<typename T >
T *	__raw_realloc_t (T *p_block, t_size p_size)
static void	__sort_2elem_helper (pfc::sort_callback &p_callback, t_size &p_elem1, t_size &p_elem2)
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_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 >
t_type *	__unsafe__in_place_constructor_array_t (t_type *p_items, t_size p_count)
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 >
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 >
void	__unsafe__in_place_destructor_t (t_type &p_item) throw ()
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 >
void	__unsafe__memcpy_t (t_type *p_dst, const t_type *p_src, t_size p_count)
template<t_size p_size>
void	__unsafe__swap_raw_t (void *p_object1, void *p_object2)
template<typename what >
static void	_COM_AddRef (what *ptr)
template<typename what >
static void	_COM_Release (what *ptr)
template<typename t_char >
int	_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	_strParamLen (const char *str)
template<typename T >
T	abs_t (T item)
template<typename t_int >
void	acc_unsigned_clipped (t_int &v1, t_int v2)
template<typename t_acc , typename t_add >
void	accumulate_guarded (t_acc &p_acc, const t_add &p_add)
template<typename t_int >
t_int	add_unsigned_clipped (t_int v1, t_int v2)
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	append_t (t_array &p_array, const T &p_item)
template<typename t_a1 , typename t_a2 >
static bool	array_equals (const t_a1 &arr1, const t_a2 &arr2)
template<typename t_array , typename t_item >
static bool	array_isFirst (const t_array &arr, const t_item &item)
template<typename t_array , typename t_item >
static bool	array_isLast (const t_array &arr, const t_item &item)
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)
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 char_t >
char_t	ascii_tolower (char_t c)
char	ascii_tolower_lookup (char c)
template<typename char_t >
char_t	ascii_toupper (char_t c)
template<typename t_type >
void	assert_raw_type ()
template<typename t_uint >
t_uint	atodec (const char *in, t_size inLen)
template<typename t_uint >
t_uint	atohex (const char *in, t_size inLen)
t_int64	atoi64_ex (const char *src, t_size len)
t_uint64	atoui64_ex (const char *src, t_size len)
unsigned	atoui_ex (const char *p_string, t_size p_string_len)
void	base64_decode (const char *text, void *out)
template<typename t_buffer >
void	base64_decode_array (t_buffer &out, const char *text)
t_size	base64_decode_estimate (const char *text)
void	base64_encode (pfc::string_base &out, const void *in, t_size inSize)
void	base64_encode_append (pfc::string_base &out, const void *in, t_size inSize)
bool	bsearch (t_size p_count, bsearch_callback const &p_callback, t_size &p_result)
template<typename t_callback >
bool	bsearch_inline_t (t_size p_count, const t_callback &p_callback, t_size &p_result)
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_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)
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)
void	bug_check_assert (bool p_condition, const char *p_msg)
void	bug_check_assert (bool p_condition)
template<typename T >
T	byteswap_if_be_t (T p_param)
template<typename T >
T	byteswap_if_le_t (T p_param)
template<typename T >
T	byteswap_int_t (T p_source)
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<>
double	byteswap_t< double > (double p_source)
template<>
float	byteswap_t< float > (float p_source)
template<>
GUID	byteswap_t< GUID > (GUID p_guid)
template<>
int	byteswap_t< int > (int p_source)
template<>
long	byteswap_t< long > (long p_source)
template<>
long long	byteswap_t< long long > (long long p_source)
template<>
short	byteswap_t< short > (short p_source)
template<>
signed char	byteswap_t< signed char > (signed char p_source)
template<>
unsigned char	byteswap_t< unsigned char > (unsigned char p_source)
template<>
unsigned int	byteswap_t< unsigned int > (unsigned int p_source)
template<>
unsigned long	byteswap_t< unsigned long > (unsigned long p_source)
template<>
unsigned long long	byteswap_t< unsigned long long > (unsigned long long p_source)
template<>
unsigned short	byteswap_t< unsigned short > (unsigned short p_source)
template<>
wchar_t	byteswap_t< wchar_t > (wchar_t p_source)
template<typename T >
t_size	calc_array_width (t_size p_width)
bool	char_is_ascii_alpha (char p_char) throw ()
bool	char_is_ascii_alpha_lower (char p_char) throw ()
bool	char_is_ascii_alpha_upper (char p_char) throw ()
bool	char_is_ascii_alphanumeric (char p_char) throw ()
bool	char_is_hexnumeric (char p_char) throw ()
template<typename char_t >
bool	char_is_numeric (char_t p_char) throw ()
unsigned	char_to_dec (char c)
unsigned	char_to_hex (char c)
uint32_t	charLower (uint32_t param)
uint32_t	charUpper (uint32_t param)
static bool	check_end_of_string (const char *ptr)
template<typename T >
T	clip_t (const T &p_item, const T &p_min, const T &p_max)
template<typename T >
T *	clone_t (T *ptr)
template<>
int	compare_t (const hasher_md5_result &p_item1, const hasher_md5_result &p_item2)
template<typename t_item1 , typename t_item2 >
int	compare_t (const t_item1 &p_item1, const t_item2 &p_item2)
template<>
int	compare_t< GUID, GUID > (const GUID &p_item1, const GUID &p_item2)
void	convert_to_lower_ascii (const char *src, t_size max, char *out, char replace)
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_to , typename t_from >
void	copy_array_t (t_to &p_to, const t_from &p_from)
template<typename t_receiver , typename t_giver >
void	copy_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
unsigned	countBits32 (uint32_t i)
void	crash ()
void	create_move_items_permutation (t_size *p_output, t_size p_count, const class bit_array &p_selection, int p_delta)
void	create_move_items_permutation (t_size *p_output, t_size p_count, const bit_array &p_selection, int p_delta)
GUID	createGUID ()
void	createPipe (int fd[2], bool bInheritable)
template<typename TInt >
void	decode_big_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt >
TInt	decode_big_endian (const t_uint8 *p_buffer)
template<bool IsBigEndian, typename TInt >
void	decode_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt >
void	decode_little_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt >
TInt	decode_little_endian (const t_uint8 *p_buffer)
template<typename T >
void	delete_array_t (T *ptr)
template<typename T >
void	delete_t (T *ptr)
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)
void	dynamic_assert (bool p_condition, const char *p_msg)
void	dynamic_assert (bool p_condition)
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 TInt >
void	encode_big_endian (t_uint8 *p_buffer, TInt p_value)
template<bool IsBigEndian, typename TInt >
void	encode_endian (t_uint8 *p_buffer, TInt p_in)
template<typename TInt >
void	encode_little_endian (t_uint8 *p_buffer, TInt p_value)
double	exp_int (double base, int exp)
bool	fdCanRead (int fd)
bool	fdCanWrite (int fd)
bool	fdWaitRead (int fd, double timeOutSeconds)
bool	fdWaitWrite (int fd, double timeOutSeconds)
void	fileHandleClose (fileHandle_t h)
fileHandle_t	fileHandleDup (fileHandle_t h)
uint64_t	fileTimeNow ()
uint64_t	fileTimeUtoW (uint64_t ft)
uint64_t	fileTimeUtoW (const timespec &ts)
uint64_t	fileTimeWtoU (uint64_t ft)
template<typename t_array , typename t_value >
void	fill_array_t (t_array &p_array, const t_value &p_value)
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_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_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_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)
void	float_to_string (char *out, t_size out_max, double val, unsigned precision, bool b_sign)
char	format_hex_char (unsigned p_val)
char	format_hex_char_lowercase (unsigned p_val)
t_size	getOptimalWorkerThreadCount ()
t_size	getOptimalWorkerThreadCountEx (t_size taskCountLimit)
template<typename t_list1 , typename t_list2 >
static bool	guess_reorder_pattern (pfc::array_t< t_size > &out, const t_list1 &from, const t_list2 &to)
int	guid_compare (const GUID &g1, const GUID &g2)
bool	guid_equal (const GUID &g1, const GUID &g2)
GUID	GUID_from_text (const char *text)
bool	has_path_bad_chars (const char *param)
template<typename t_ret >
t_ret	implicit_cast (t_ret val)
double	importTimeval (const timeval &in)
template<typename array1_t , typename array2_t >
void	insert_array_t (array1_t &outArray, size_t insertAt, array2_t const &inArray, size_t inArraySize)
template<typename t_array , typename in_array_t >
t_size	insert_multi_t (t_array &p_array, const in_array_t &p_items, size_t p_itemCount, 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_array , typename T >
t_size	insert_t (t_array &p_array, const T &p_item, t_size p_index)
template<typename t_array >
t_size	insert_uninitialized_t (t_array &p_array, t_size p_index)
bool	is_lower_ascii (const char *param)
bool	is_multiline (const char *p_string, t_size p_len)
bool	is_path_bad_char (unsigned c)
bool	is_path_separator (unsigned c)
template<typename t_item >
bool	is_pointer_in_range (const t_item *p_buffer, t_size p_buffer_size, const void *p_pointer)
template<t_size p_size_pow2>
bool	is_ptr_aligned_t (const void *p_ptr)
bool	is_valid_utf8 (const char *param, t_size max=~0)
bool	isAltKeyPressed ()
bool	isCtrlKeyPressed ()
bool	isShiftKeyPressed ()
template<typename t_list , typename t_array >
void	list_to_array (t_array &p_array, const t_list &p_list)
template<typename t_list1 , typename t_list2 >
static bool	listEquals (const t_list1 &p_list1, const t_list2 &p_list2)
bool	lxor (bool p_val1, bool p_val2)
GUID	makeGUID (t_uint32 Data1, t_uint16 Data2, t_uint16 Data3, t_uint8 Data4_1, t_uint8 Data4_2, t_uint8 Data4_3, t_uint8 Data4_4, t_uint8 Data4_5, t_uint8 Data4_6, t_uint8 Data4_7, t_uint8 Data4_8)
timeval	makeTimeVal (double timeSeconds)
template<typename t_val >
void	max_acc (t_val &p_acc, const t_val &p_val)
template<typename T >
T	max_t (const T &item1, const T &item2)
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_src , typename t_dst >
void	memcpy_t (t_dst *p_dst, const t_src *p_src, t_size p_count)
template<typename T >
void	memmove_t (T *p_dst, const T *p_src, t_size p_count)
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 , 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)
static void	memxor (void *target, const void *source1, const void *source2, t_size size)
template<typename TVal >
void	memxor_t (TVal *out, const TVal *s1, const TVal *s2, t_size count)
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_source1 , typename t_source2 >
t_size	merge_sorted_lists_calculate_count (const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_val >
void	min_acc (t_val &p_acc, const t_val &p_val)
template<typename T >
T	min_t (const T &item1, const T &item2)
template<typename T >
void	move_t (T &p_item1, T &p_item2)
template<typename t_exception , typename t_int >
t_int	mul_safe_t (t_int p_val1, t_int p_val2)
template<typename t_int >
t_int	multiply_guarded (t_int v1, t_int v2)
void	myassert (const wchar_t *_Message, const wchar_t *_File, unsigned _Line)
static t_size	myrand (t_size count)
int	naturalSortCompare (const char *s1, const char *s2) throw ()
int	naturalSortCompareI (const char *s1, const char *s2) throw ()
static int	naturalSortCompareInternal (const char *s1, const char *s2, bool insensitive) throw ()
template<typename T >
T *	new_ptr_check_t (T *p_ptr)
static void	newsort (pfc::sort_callback &p_callback, t_size const p_base, t_size const p_count)
void	nixFormatError (string_base &str, int code)
void	nixGetRandomData (void *outPtr, size_t outBytes)
double	nixGetTime ()
bool	nixReadSymLink (string_base &strOut, const char *path)
bool	nixSelfProcessPath (string_base &strOut)
void	nixSleep (double seconds)
template<typename t_receiver , typename t_giver >
void	overwrite_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
double	parse_timecode (const char *in)
static size_t	parseNumber (const char *in, uint64_t &outNumber)
t_size	permutation_find_reverse (t_size const *order, t_size count, t_size value)
bool	permutation_is_valid (t_size const *order, t_size count)
void	permutation_validate (t_size const *order, t_size count)
	PFC_DECLARE_EXCEPTION (exception_invalid_permutation, exception_invalid_params,"Invalid permutation")
	PFC_DECLARE_EXCEPTION (exception_map_entry_not_found, exception,"Map entry not found")
	PFC_DECLARE_EXCEPTION (exception_overflow, exception,"Overflow")
	PFC_DECLARE_EXCEPTION (exception_bug_check, exception,"Bug check")
	PFC_DECLARE_EXCEPTION (exception_invalid_params, exception_bug_check,"Invalid parameters")
	PFC_DECLARE_EXCEPTION (exception_unexpected_recursion, exception_bug_check,"Unexpected recursion")
	PFC_DECLARE_EXCEPTION (exception_not_implemented, exception_bug_check,"Feature not implemented")
	PFC_DECLARE_EXCEPTION (exception_dynamic_assert, exception_bug_check,"dynamic_assert failure")
static double	pfc_string_to_float_internal (const char *src)
static t_uint64	pow10_helper (unsigned p_extra)
t_uint64	pow_int (t_uint64 base, t_uint64 exp)
static void	print_hex (unsigned val, char *&out, unsigned bytes)
static char	print_hex_digit (unsigned val)
void	print_hex_raw (const void *buffer, unsigned bytes, char *p_out)
bool	query_cpu_feature_set (unsigned p_value)
static void	raw_free (void *p_block) throw ()
static void *	raw_malloc (t_size p_size)
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_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)
void	recover_invalid_utf8 (const char *src, char *out, unsigned replace)
template<typename t_array >
t_size	remove_mask_t (t_array &p_array, const bit_array &p_mask)
void	reorder (reorder_callback &p_callback, 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)
template<typename t_container >
void	reorder_t (t_container &p_data, const t_size *p_order, t_size p_count)
void	reorder_void (void *data, t_size width, const t_size *order, t_size num, void(*swapfunc)(void *item1, void *item2, t_size width))
template<typename t_type >
t_type	replace_null_t (t_type &p_var)
template<typename t_type , typename t_newval >
t_type	replace_t (t_type &p_var, const t_newval &p_newval)
template<unsigned width>
void	reverse_bytes (t_uint8 *p_buffer)
template<>
void	reverse_bytes< 0 > (t_uint8 *p_buffer)
template<>
void	reverse_bytes< 1 > (t_uint8 *p_buffer)
t_int32	rint32 (double p_val)
t_int64	rint64 (double p_val)
template<typename t_ret , typename t_param >
t_ret *	safe_ptr_cast (t_param *p_param)
template<typename t_exception , typename t_int >
t_int	safe_shift_left_t (t_int p_val, t_size p_shift=1)
static uint64_t	safeMulAdd (uint64_t prev, unsigned scale, uint64_t add)
t_size	scan_filename (const char *ptr)
void	selftest ()
void	setCloseOnExec (int fd, bool bCloseOnExec)
void	setInheritable (int fd, bool bInheritable)
void	setNonBlocking (int fd, bool bNonBlocking)
template<typename T >
int	sgn_t (const T &p_val)
t_size	skip_utf8_chars (const char *ptr, t_size count) throw ()
void	sort (pfc::sort_callback &p_callback, t_size p_num)
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)
void	sort_stable (sort_callback &p_callback, t_size p_count)
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)
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 >
static void	sort_t (t_container &p_data, t_compare p_compare, t_size p_count)
void	sort_void (void *base, t_size num, t_size width, int(*comp)(const void *, const void *))
void	sort_void_ex (void *base, t_size num, t_size width, int(*comp)(const void *, const void *), void(*swap)(void *, void *, t_size))
template<typename t_out >
void	splitStringByChar (t_out &out, const char *str, char c)
template<typename t_out >
void	splitStringByLines (t_out &out, const char *str)
template<typename t_out >
void	splitStringBySubstring (t_out &out, const char *str, const char *split)
template<typename t_output , typename t_splitCheck >
void	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	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	splitStringSimple_toList (t_list &p_output, t_split p_split, const char *p_string, t_size p_stringLen=~0)
template<typename T >
T	sqr_t (T item)
static void	squaresort (pfc::sort_callback &p_callback, t_size const p_base, t_size const p_count)
int	strcmp_ex (const char *p1, t_size n1, const char *p2, t_size n2) throw ()
int	strcmp_nc (const char *p1, size_t n1, const char *p2, size_t n2) throw ()
int	strcmp_partial (const char *str, const char *substr) throw ()
int	strcmp_partial_ex (const char *str, t_size strLen, const char *substr, t_size substrLen) throw ()
template<typename t_char >
int	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	strcmp_partial_t (const t_char *p_string, const t_char *p_substring) throw ()
template<typename char_t >
void	strcpy_t (char_t *out, const char_t *in)
t_size	strcpy_utf8_truncate (const char *src, char *out, t_size maxbytes)
unsigned	strcpy_utf8_truncate (const char *src, char *out, unsigned maxbytes)
char *	strdup_n (const char *src, t_size len)
int	stricmp_ascii (const char *s1, const char *s2) throw ()
int	stricmp_ascii_ex (const char *const s1, t_size const len1, const char *const s2, t_size const len2) throw ()
int	stricmp_ascii_partial (const char *str, const char *substr) throw ()
t_size	string_find_first (const char *p_string, char p_tofind, t_size p_start)
t_size	string_find_first (const char *p_string, const char *p_tofind, t_size p_start)
t_size	string_find_first_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start)
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)
t_size	string_find_first_nc (const char *p_string, t_size p_string_length, char c, t_size p_start)
t_size	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	string_find_last (const char *p_string, char p_tofind, t_size p_start)
t_size	string_find_last (const char *p_string, const char *p_tofind, t_size p_start)
t_size	string_find_last_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start)
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)
bool	string_has_prefix (const char *string, const char *prefix)
bool	string_has_prefix_i (const char *string, const char *prefix)
bool	string_has_suffix (const char *string, const char *suffix)
bool	string_has_suffix_i (const char *string, const char *suffix)
bool	string_is_numeric (const char *p_string, t_size p_length) throw ()
string_part_ref	string_part (const char *ptr, t_size len)
double	string_to_float (const char *src, t_size max)
template<typename t_source >
static void	stringCombine (pfc::string_base &out, t_source const &in, const char *separator, const char *separatorLast)
template<typename TList >
string	stringCombineList (const TList &list, stringp separator)
int	stringCompareCaseInsensitive (const char *s1, const char *s2)
int	stringCompareCaseInsensitiveEx (string_part_ref s1, string_part_ref s2)
bool	stringEqualsI_ascii (const char *p1, const char *p2) throw ()
bool	stringEqualsI_utf8 (const char *p1, const char *p2) throw ()
template<typename TChar , t_size len, typename TSource >
void	stringToBuffer (TChar(&buffer)[len], const TSource &source)
template<typename TChar , t_size len, typename TSource >
void	stringToBufferGuarded (TChar(&buffer)[len], const TSource &source)
void	stringToLowerAppend (string_base &out, const char *src, t_size len)
template<typename T >
const char *	stringToPtr (T const &val)
template<>
const char *	stringToPtr (std::string const &val)
const char *	stringToPtr (const char *val)
template<typename T >
static string_part_ref	stringToRef (T const &val)
string_part_ref	stringToRef (string_part_ref val)
string_part_ref	stringToRef (const char *val)
void	stringToUpperAppend (string_base &out, const char *src, t_size len)
t_size	strlen_max (const char *ptr, t_size max) throw ()
template<typename t_char >
t_size	strlen_max_t (const t_char *ptr, t_size max)
template<typename t_char >
t_size	strlen_t (const t_char *p_string, t_size p_length=~0)
t_size	strlen_utf8 (const char *s, t_size num=~0) throw ()
t_size	strstr_ex (const char *p_string, t_size p_string_len, const char *p_substring, t_size p_substring_len) throw ()
template<typename t_int >
t_int	sub_unsigned_clipped (t_int v1, t_int v2)
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	subtract_sorted_lists_calculate_count (const t_source1 &p_source1, const t_source2 &p_source2)
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<typename T >
void	swap_t (T &p_item1, T &p_item2)
template<>
void	swap_t (string8 &p_item1, string8 &p_item2)
void	swap_void (void *item1, void *item2, t_size width)
t_size	tcslen_max (const TCHAR *ptr, t_size max)
template<typename t_exception >
PFC_NORETURN void	throw_exception_with_message (const char *p_message)
template<typename T >
string	toString (T const &val)
template<>
string	toString (t_int64 const &val)
template<>
string	toString (t_int32 const &val)
template<>
string	toString (t_int16 const &val)
template<>
string	toString (t_uint64 const &val)
template<>
string	toString (t_uint32 const &val)
template<>
string	toString (t_uint16 const &val)
template<>
string	toString (float const &val)
template<>
string	toString (double const &val)
template<>
string	toString (char const &val)
const char *	toString (std::exception const &val)
static t_uint64	uniqueVal ()
void	urlEncode (pfc::string_base &out, const char *in)
void	urlEncodeAppend (pfc::string_base &out, const char *in)
void	urlEncodeAppendRaw (pfc::string_base &out, const char *in, t_size inSize)
t_size	utf16_decode_char (const char16_t *p_source, unsigned *p_out, t_size p_source_length=~0) throw ()
t_size	utf16_decode_char (const wchar_t *p_source, unsigned *p_out, t_size p_source_length=~0) throw ()
t_size	utf16_encode_char (unsigned c, char16_t *out) throw ()
t_size	utf16_encode_char (unsigned c, wchar_t *out) throw ()
bool	utf8_advance (const char *&var) throw ()
bool	utf8_advance (char *&var) throw ()
t_size	utf8_char_len (const char *s, t_size max=~0) throw ()
t_size	utf8_char_len_from_header (char c) throw ()
const char *	utf8_char_next (const char *src) throw ()
char *	utf8_char_next (char *src) throw ()
t_size	utf8_chars_to_bytes (const char *string, t_size count) throw ()
t_size	utf8_decode_char (const char *src, unsigned &out, t_size src_bytes) throw ()
t_size	utf8_decode_char (const char *src, unsigned &out) throw ()
t_size	utf8_encode_char (unsigned c, char *out) throw ()
unsigned	utf8_get_char (const char *src)
t_size	wcslen_max (const wchar_t *ptr, t_size max) throw ()
t_size	wide_decode_char (const wchar_t *p_source, unsigned *p_out, t_size p_source_length=~0) throw ()
t_size	wide_encode_char (unsigned c, wchar_t *out) throw ()
BOOL	winFormatSystemErrorMessage (pfc::string_base &p_out, DWORD p_code)
void	winPrefixPath (pfc::string_base &out, const char *p_path)
void	winUnPrefixPath (pfc::string_base &out, const char *p_path)
GUID	xorGUID (const GUID &v1, const GUID &v2)

Variables
static const t_uint8	ascii_tolower_table [128] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F}
static const bool	byte_order_is_big_endian = !!PFC_BYTE_ORDER_IS_BIG_ENDIAN
static const bool	byte_order_is_little_endian = !!PFC_BYTE_ORDER_IS_LITTLE_ENDIAN
const fileHandle_t	fileHandleInvalid = INVALID_HANDLE_VALUE
const GUID	guid_null = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } }
const t_uint16	infinite16 = (t_uint16)(~0)
const t_uint32	infinite32 = (t_uint32)(~0)
const t_uint64	infinite64 = (t_uint64)(~0)
const t_size	infinite_size = (t_size)(~0)
static const t_uint8	mask_tab [6] ={0x80,0xE0,0xF0,0xF8,0xFC,0xFE}
static const t_rcptr_null	rcptr_null = NULL
static counter	uniqueValCounter
static const t_uint8	val_tab [6] ={0,0xC0,0xE0,0xF0,0xF8,0xFC}

---

Data Structure Documentation

class pfc::_splitStringSimple_check

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

Definition at line 896 of file string_base.h.

class pfc::alloc_fixed

template<t_size p_width>
class pfc::alloc_fixed< p_width >

Definition at line 415 of file alloc.h.

class pfc::alloc_hybrid

template<t_size p_width, template< typename > class t_alloc = alloc_standard>
class pfc::alloc_hybrid< p_width, t_alloc >

Definition at line 466 of file alloc.h.

class pfc::assert_byte_type

template<typename t_type>
class pfc::assert_byte_type< t_type >

Definition at line 101 of file primitives.h.

class pfc::assert_byte_type< char >

template<>
class pfc::assert_byte_type< char >

Definition at line 102 of file primitives.h.

class pfc::assert_byte_type< signed char >

template<>
class pfc::assert_byte_type< signed char >

Definition at line 104 of file primitives.h.

class pfc::assert_byte_type< unsigned char >

template<>
class pfc::assert_byte_type< unsigned char >

Definition at line 103 of file primitives.h.

class pfc::assert_same_type

template<typename p_type1, typename p_type2>
class pfc::assert_same_type< p_type1, p_type2 >

Definition at line 85 of file primitives.h.

class pfc::assert_same_type< p_type, p_type >

template<typename p_type>
class pfc::assert_same_type< p_type, p_type >

Definition at line 86 of file primitives.h.

class pfc::combine_traits

template<typename traits1, typename traits2>
class pfc::combine_traits< traits1, traits2 >

Definition at line 46 of file traits.h.

Data Fields
	__unnamed__

class pfc::int_specs_t

template<typename T>
class pfc::int_specs_t< T >

Definition at line 62 of file int_types.h.

class pfc::is_same_type

template<typename p_type1, typename p_type2>
class pfc::is_same_type< p_type1, p_type2 >

Definition at line 89 of file primitives.h.

Data Fields
	__unnamed__

class pfc::is_same_type< p_type, p_type >

template<typename p_type>
class pfc::is_same_type< p_type, p_type >

Definition at line 91 of file primitives.h.

Data Fields
	__unnamed__

class pfc::sized_int_t

template<unsigned t_bytes>
class pfc::sized_int_t< t_bytes >

Definition at line 21 of file int_types.h.

class pfc::sized_int_t< 1 >

template<>
class pfc::sized_int_t< 1 >

Definition at line 23 of file int_types.h.

Data Fields
typedef t_int8	t_signed
typedef t_uint8	t_unsigned

class pfc::sized_int_t< 2 >

template<>
class pfc::sized_int_t< 2 >

Definition at line 29 of file int_types.h.

Data Fields
typedef t_int16	t_signed
typedef t_uint16	t_unsigned

class pfc::sized_int_t< 4 >

template<>
class pfc::sized_int_t< 4 >

Definition at line 35 of file int_types.h.

Data Fields
typedef t_int32	t_signed
typedef t_uint32	t_unsigned

class pfc::sized_int_t< 8 >

template<>
class pfc::sized_int_t< 8 >

Definition at line 41 of file int_types.h.

Data Fields
typedef t_int64	t_signed
typedef t_uint64	t_unsigned

class pfc::static_assert_t

template<bool val>
class pfc::static_assert_t< val >

Definition at line 93 of file primitives.h.

class pfc::static_assert_t< true >

template<>
class pfc::static_assert_t< true >

Definition at line 94 of file primitives.h.

class pfc::traits_vtable

Definition at line 33 of file traits.h.

Data Fields
	__unnamed__

Typedef Documentation

typedef vartoggle_t<bool> pfc::booltoggle

Definition at line 16 of file other.h.

typedef nix_event pfc::event

Definition at line 16 of file event.h.

typedef int pfc::eventHandle_t

Definition at line 4 of file event.h.

typedef std::exception pfc::exception

Definition at line 193 of file primitives.h.

typedef int pfc::fileHandle_t

Definition at line 3 of file filehandle.h.

typedef hires_timer pfc::lores_timer

Definition at line 116 of file timers.h.

typedef ptr_list_t<void> pfc::ptr_list

Definition at line 41 of file ptr_list.h.

typedef counter pfc::refcounter

Definition at line 35 of file ref_counter.h.

typedef string8_t<pfc::alloc_standard> pfc::string8

Definition at line 431 of file string_base.h.

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

Definition at line 432 of file string_base.h.

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

Definition at line 433 of file string_base.h.

typedef string8_t<pfc::alloc_fast_aggressive> pfc::string8_fastalloc

Definition at line 435 of file string_base.h.

typedef string8_fastalloc pfc::string_formatter

Definition at line 614 of file string_base.h.

typedef list_base_const_t<const char*> pfc::string_list_const

Definition at line 6 of file string_list.h.

typedef string_simple_t<char> pfc::string_simple

Definition at line 824 of file string_base.h.

typedef _rcptr_null* pfc::t_rcptr_null

Definition at line 3 of file rcptr.h.

Enumeration Type Documentation

anonymous enum

Enumerator
CPU_HAVE_3DNOW
CPU_HAVE_3DNOW_EX
CPU_HAVE_SSE
CPU_HAVE_SSE2
CPU_HAVE_SSE3
CPU_HAVE_SSSE3
CPU_HAVE_SSE41
CPU_HAVE_SSE42

Definition at line 6 of file cpuid.h.

         {
        CPU_HAVE_3DNOW      = 1 << 0,
        CPU_HAVE_3DNOW_EX   = 1 << 1,
        CPU_HAVE_SSE        = 1 << 2,
        CPU_HAVE_SSE2       = 1 << 3,
        CPU_HAVE_SSE3       = 1 << 4,
        CPU_HAVE_SSSE3      = 1 << 5,
        CPU_HAVE_SSE41      = 1 << 6,
        CPU_HAVE_SSE42      = 1 << 7,
    };

Function Documentation

static t_size pfc::__pivot_helper ( pfc::sort_callback &  p_callback, t_size const  p_base, t_size const  p_count  )

inlinestatic

Definition at line 164 of file sort.cpp.

                                                                                                            {
    PFC_ASSERT(p_count > 2);
    
    //t_size val1 = p_base, val2 = p_base + (p_count / 2), val3 = p_base + (p_count - 1);
    
    t_size val1 = myrand(p_count), val2 = myrand(p_count-1), val3 = myrand(p_count-2);
    if (val2 >= val1) val2++;
    if (val3 >= val1) val3++;
    if (val3 >= val2) val3++;

    val1 += p_base; val2 += p_base; val3 += p_base;
    
    __sort_2elem_helper(p_callback,val1,val2);
    __sort_2elem_helper(p_callback,val1,val3);
    __sort_2elem_helper(p_callback,val2,val3);

    return val2;
}

template<typename T >

void pfc::__raw_free_t	(	T *	p_block	)
throw	(
	)

Definition at line 36 of file alloc.h.

                                           {
        raw_free(reinterpret_cast<void*>(p_block));
    }

template<typename T >

T* pfc::__raw_malloc_t

(

t_size

p_size

)

Definition at line 31 of file alloc.h.

                                      {
        return reinterpret_cast<T*>(raw_malloc(calc_array_width<T>(p_size)));
    }

template<typename T >

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

Definition at line 46 of file alloc.h.

                                                            {
        return raw_realloc_inplace(p_block,calc_array_width<T>(p_size));
    }

template<typename T >

T* pfc::__raw_realloc_t	(	T *	p_block,
		t_size	p_size
	)

Definition at line 41 of file alloc.h.

                                                   {
        return reinterpret_cast<T*>(raw_realloc(p_block,calc_array_width<T>(p_size)));
    }

static void pfc::__sort_2elem_helper ( pfc::sort_callback &  p_callback, t_size &  p_elem1, t_size &  p_elem2  )

inlinestatic

Definition at line 137 of file sort.cpp.

                                                                                                        {
    if (p_callback.compare(p_elem1,p_elem2) > 0) pfc::swap_t(p_elem1,p_elem2);
}

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
	)

Definition at line 170 of file primitives.h.

                                                                                                                                                                                               {
        if (p_copyfrom_count > p_count) p_copyfrom_count = p_count;
        __unsafe__in_place_constructor_array_copy_t(p_items,p_copyfrom_count,p_copyfrom);
        try {
            __unsafe__in_place_constructor_array_t(p_items + p_copyfrom_count,p_count - p_copyfrom_count);
        } catch(...) {
            __unsafe__in_place_destructor_array_t(p_items,p_copyfrom_count);
            throw;
        }
        return p_items;
    }

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
	)

Definition at line 159 of file primitives.h.

                                                                                                                                                               {
        t_size walkptr = 0;
        try {
            for(walkptr=0;walkptr<p_count;++walkptr) __unsafe__in_place_constructor_copy_t(p_items[walkptr],p_copyfrom[walkptr]);
        } catch(...) {
            __unsafe__in_place_destructor_array_t(p_items,walkptr);
            throw;
        }
        return p_items;
    }

template<typename t_type >

t_type* pfc::__unsafe__in_place_constructor_array_t	(	t_type *	p_items,
		t_size	p_count
	)

Definition at line 130 of file primitives.h.

                                                                                                               {
        if (traits_t<t_type>::needs_constructor) {
            t_size walkptr = 0;
            try {
                for(walkptr=0;walkptr<p_count;++walkptr) __unsafe__in_place_constructor_t(p_items[walkptr]);
            } catch(...) {
                __unsafe__in_place_destructor_array_t(p_items,walkptr);
                throw;
            }
        }
        return p_items;
    }

template<typename t_type , typename t_copy >

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

Definition at line 149 of file primitives.h.

                                                                                                                                    {
        if (traits_t<t_type>::needs_constructor) {
            t_type * ret = new(&p_item) t_type(p_copyfrom);
            PFC_ASSERT(ret == &p_item);
            (void) ret; // suppress warning
        } else {
            p_item = p_copyfrom;
        }
    }

template<typename t_type >

void pfc::__unsafe__in_place_constructor_t

(

t_type &

p_item

)

Definition at line 115 of file primitives.h.

                                                                                     {
        if (traits_t<t_type>::needs_constructor) {
            t_type * ret = new(&p_item) t_type;
            PFC_ASSERT(ret == &p_item);
            (void) ret; // suppress warning
        }
    }

template<typename t_type >

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

Definition at line 123 of file primitives.h.

                                                                                                                   {
        if (traits_t<t_type>::needs_destructor) {
            t_type * walk = p_items;
            for(t_size n=p_count;n;--n) __unsafe__in_place_destructor_t(*(walk++));
        }
    }

template<typename t_type >

void pfc::__unsafe__in_place_destructor_t	(	t_type &	p_item	)
throw	(
	)

Definition at line 111 of file primitives.h.

                                                                                            {
        if (traits_t<t_type>::needs_destructor) try{ p_item.~t_type(); } catch(...) {}
    }

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
	)

Definition at line 143 of file primitives.h.

                                                                                                                     {
        if (p_from < p_to) __unsafe__in_place_constructor_array_t(p_items + p_from, p_to - p_from);
        else if (p_from > p_to) __unsafe__in_place_destructor_array_t(p_items + p_to, p_from - p_to);
        return p_items;
    }

template<typename t_type >

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

Definition at line 107 of file primitives.h.

                                                                                                          {
        ::memcpy(reinterpret_cast<void*>(p_dst), reinterpret_cast<const void*>(p_src), p_count * sizeof(t_type));
    }

template<t_size p_size>

void pfc::__unsafe__swap_raw_t ( void *  p_object1, void *  p_object2  )

inline

Definition at line 276 of file primitives.h.

                                                                         {
        if (p_size % sizeof(t_size) == 0) {
            swap_multi_t<t_size,p_size/sizeof(t_size)>(reinterpret_cast<t_size*>(p_object1),reinterpret_cast<t_size*>(p_object2));
        } else {
            swap_multi_t<t_uint8,p_size>(reinterpret_cast<t_uint8*>(p_object1),reinterpret_cast<t_uint8*>(p_object2));
        }
    }

template<typename what >

static void pfc::_COM_AddRef ( what *  ptr )

static

Definition at line 4 of file com_ptr_t.h.

                                                                {
        if (ptr != NULL) ptr->AddRef();
    }

template<typename what >

static void pfc::_COM_Release ( what *  ptr )

static

Definition at line 7 of file com_ptr_t.h.

                                                                 {
        if (ptr != NULL) ptr->Release();
    }

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	(
	)

Definition at line 1069 of file string_base.h.

                                                                                                                                                                  {
        for(t_size walk=0;walk<p_substring_length;walk++) {
            t_char stringchar = (walk>=p_string_length ? 0 : p_string[walk]);
            t_char substringchar = p_substring[walk];
            int result = compare_t(stringchar,substringchar);
            if (result != 0) return result;
        }
        return 0;
    }

t_size pfc::_strParamLen ( const char *  str )

inline

Definition at line 7 of file string_base.h.

                                                 {
        return strlen(str);
    }

template<typename T >

T pfc::abs_t ( T  item )

inline

Definition at line 559 of file primitives.h.

{return item<0 ? -item : item;}

template<typename t_int >

void pfc::acc_unsigned_clipped	(	t_int &	v1,
		t_int	v2
	)

Definition at line 606 of file primitives.h.

                                                                             {
        v1 = add_unsigned_clipped(v1, v2);
    }

template<typename t_acc , typename t_add >

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

Definition at line 217 of file primitives.h.

                                                                {
        t_acc delta = downcast_guarded<t_acc>(p_add);
        delta += p_acc;
        if (delta < p_acc) throw exception_overflow();
        p_acc = delta;
    }

template<typename t_int >

t_int pfc::add_unsigned_clipped	(	t_int	v1,
		t_int	v2
	)

Definition at line 596 of file primitives.h.

                                                                            {
        t_int v = v1 + v2;
        if (v < v1) return ~0;
        return v;
    }

template<typename t_array , typename T >

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

inline

Definition at line 482 of file primitives.h.

    {
        t_size old_count = p_array.get_size();
        p_array.set_size(old_count + 1);
        swap_t(p_array[old_count],p_item);
        return old_count;
    }

template<typename t_array , typename T >

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

inline

Definition at line 473 of file primitives.h.

    {
        t_size old_count = p_array.get_size();
        p_array.set_size(old_count + 1);
        p_array[old_count] = p_item;
        return old_count;
    }

template<typename t_a1 , typename t_a2 >

static bool pfc::array_equals ( const t_a1 &  arr1, const t_a2 &  arr2  )

static

Definition at line 278 of file array.h.

                                                                   {
        const t_size s = array_size_t(arr1);
        if (s != array_size_t(arr2)) return false;
        for(t_size walk = 0; walk < s; ++walk) {
            if (arr1[walk] != arr2[walk]) return false;
        }
        return true;
    }

template<typename t_array , typename t_item >

static bool pfc::array_isFirst ( const t_array &  arr, const t_item &  item  )

static

Definition at line 318 of file primitives.h.

                                                                                                                    {
        const t_size size = pfc::array_size_t(arr);
        return size > 0 && arr[0] == item;
    }

template<typename t_array , typename t_item >

static bool pfc::array_isLast ( const t_array &  arr, const t_item &  item  )

static

Definition at line 314 of file primitives.h.

                                                                                                                   {
        const t_size size = pfc::array_size_t(arr);
        return size > 0 && arr[size-1] == item;
    }

template<typename t_array >

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

Definition at line 702 of file primitives.h.

                                                                    {
        if (p_index >= pfc::array_size_t(p_array)) throw pfc::exception_overflow();
    }

template<typename t_array >

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

Definition at line 707 of file primitives.h.

                                                                               {
        if (p_from > p_to) throw pfc::exception_overflow();
        array_rangecheck_t(p_array,p_from); array_rangecheck_t(p_array,p_to);
    }

template<typename t_array >

t_size pfc::array_size_t

(

const t_array &

p_array

)

Definition at line 309 of file primitives.h.

{return p_array.get_size();}

template<typename t_item , t_size p_width>

t_size pfc::array_size_t

(

const t_item(&)

p_array[p_width]

)

Definition at line 312 of file primitives.h.

{return p_width;}

template<typename char_t >

char_t pfc::ascii_tolower ( char_t  c )

inline

Definition at line 60 of file string_base.h.

{if (c >= 'A' && c <= 'Z') c += 'a' - 'A'; return c;}

char pfc::ascii_tolower_lookup

(

char

c

)

Definition at line 1162 of file string_base.cpp.

                                  {
    PFC_ASSERT( c >= 0);
    return (char)ascii_tolower_table[c];
}

template<typename char_t >

char_t pfc::ascii_toupper ( char_t  c )

inline

Definition at line 61 of file string_base.h.

{if (c >= 'a' && c <= 'z') c += 'A' - 'a'; return c;}

template<typename t_type >

void pfc::assert_raw_type

(

)

Definition at line 99 of file primitives.h.

{static_assert_t< !traits_t<t_type>::needs_constructor && !traits_t<t_type>::needs_destructor >();}

template<typename t_uint >

t_uint pfc::atodec	(	const char *	in,
		t_size	inLen
	)

Definition at line 124 of file string_base.h.

                                                                           {
        t_uint ret = 0;
        for(t_size walk = 0; walk < inLen; ++walk) {
            const t_uint prev = ret;
            ret = (ret * 10) + char_to_dec(in[walk]);
            if ((ret / 10) != prev) throw exception_overflow();
        }
        return ret;
    }

template<typename t_uint >

t_uint pfc::atohex	(	const char *	in,
		t_size	inLen
	)

Definition at line 115 of file string_base.h.

                                                                           {
        t_uint ret = 0;
        const t_uint guard = (t_uint)0xF << (sizeof(t_uint) * 8 - 4);
        for(t_size walk = 0; walk < inLen; ++walk) {
            if (ret & guard) throw exception_overflow();
            ret = (ret << 4) | char_to_hex(in[walk]);
        }
        return ret;
    }

t_int64 pfc::atoi64_ex	(	const char *	src,
		t_size	len
	)

Definition at line 363 of file string_base.cpp.

{
    len = strlen_max(src,len);
    t_int64 ret = 0, mul = 1;
    t_size ptr = len;
    t_size start = 0;
    bool neg = false;
//  start += skip_spacing(src+start,len-start);
    if (start < len && src[start] == '-') {neg = true; start++;}
//  start += skip_spacing(src+start,len-start);
    
    while(ptr>start)
    {
        char c = src[--ptr];
        if (c>='0' && c<='9')
        {
            ret += (c-'0') * mul;
            mul *= 10;
        }
        else
        {
            ret = 0;
            mul = 1;
        }
    }
    return neg ? -ret : ret;
}

t_uint64 pfc::atoui64_ex	(	const char *	src,
		t_size	len
	)

Definition at line 338 of file string_base.cpp.

                                                 {
    len = strlen_max(src,len);
    t_uint64 ret = 0, mul = 1;
    t_size ptr = len;
    t_size start = 0;
//  start += skip_spacing(src+start,len-start);
    
    while(ptr>start)
    {
        char c = src[--ptr];
        if (c>='0' && c<='9')
        {
            ret += (c-'0') * mul;
            mul *= 10;
        }
        else
        {
            ret = 0;
            mul = 1;
        }
    }
    return ret;
}

unsigned pfc::atoui_ex	(	const char *	p_string,
		t_size	p_string_len
	)

Definition at line 303 of file string_base.cpp.

{
    unsigned ret = 0; t_size ptr = 0;
    while(ptr<p_string_len)
    {
        char c = p_string[ptr];
        if (! ( c >= '0' && c <= '9' ) ) break;
        ret = ret * 10 + (unsigned)( c - '0' );
        ptr++;
    }
    return ret;
}

void pfc::base64_decode	(	const char *	text,
		void *	out
	)

Definition at line 36 of file base64.cpp.

                                                      {
        static const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        t_uint8 alphabetRev[256];
        for(t_size walk = 0; walk < PFC_TABSIZE(alphabetRev); ++walk) alphabetRev[walk] = 0xFF;
        for(t_size walk = 0; walk < PFC_TABSIZE(alphabet); ++walk) alphabetRev[alphabet[walk]] = (t_uint8)walk;
        const t_size textLen = strlen(text);

        if (textLen % 4 != 0) throw pfc::exception_invalid_params();
        if (textLen == 0) return;
        
        t_size outWritePtr = 0;

        {
            const t_size max = textLen - 4;
            t_size textWalk = 0;
            for(; textWalk < max; textWalk ++) {
                const t_uint8 v = alphabetRev[(t_uint8)text[textWalk]];
                if (v == 0xFF) throw pfc::exception_invalid_params();
                bitWriter::set_bits(reinterpret_cast<t_uint8*>(out),outWritePtr,v,6);
                outWritePtr += 6;
            }

            t_uint8 temp[3];
            t_size tempWritePtr = 0;
            for(; textWalk < textLen; textWalk ++) {
                const char c = text[textWalk];
                if (c == '=') break;
                const t_uint8 v = alphabetRev[(t_uint8)c];
                if (v == 0xFF) throw pfc::exception_invalid_params();
                bitWriter::set_bits(temp,tempWritePtr,v,6);
                tempWritePtr += 6;
            }
            for(; textWalk < textLen; textWalk ++) {
                if (text[textWalk] != '=') throw pfc::exception_invalid_params();
            }
            memcpy(reinterpret_cast<t_uint8*>(out) + (outWritePtr/8), temp, tempWritePtr/8);
        }
    }

template<typename t_buffer >

void pfc::base64_decode_array	(	t_buffer &	out,
		const char *	text
	)

Definition at line 8 of file base64.h.

                                                                                            {
        PFC_STATIC_ASSERT( sizeof(out[0]) == 1 );
        out.set_size_discard( base64_decode_estimate(text) );
        base64_decode(text, out.get_ptr());
    }

t_size pfc::base64_decode_estimate

(

const char *

text

)

Definition at line 18 of file base64.cpp.

                                                     {
        t_size textLen = strlen(text);
        if (textLen % 4 != 0) throw pfc::exception_invalid_params();
        t_size outLen = (textLen / 4) * 3;
        
        if (textLen >= 4) {
            if (text[textLen-1] == '=') {
                textLen--; outLen--;
                if (text[textLen-1] == '=') {
                    textLen--; outLen--;
                }
            }
        }
        return outLen;
    }

void pfc::base64_encode	(	pfc::string_base &	out,
		const void *	in,
		t_size	inSize
	)

Definition at line 74 of file base64.cpp.

                                                                             {
        out.reset(); base64_encode_append(out, in, inSize);
    }

void pfc::base64_encode_append	(	pfc::string_base &	out,
		const void *	in,
		t_size	inSize
	)

Definition at line 77 of file base64.cpp.

                                                                                    {
        static const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        int shift = 0;
        int accum = 0;
        const t_uint8 * inPtr = reinterpret_cast<const t_uint8*>(in);

        for(t_size walk = 0; walk < inSize; ++walk) {
            accum <<= 8;
            shift += 8;
            accum |= inPtr[walk];
            while ( shift >= 6 ) {
                shift -= 6;
                out << format_char( alphabet[(accum >> shift) & 0x3F] );
            }
        }
        if (shift == 4) {
            out << format_char( alphabet[(accum & 0xF)<<2] ) << "=";
        } else if (shift == 2) {
            out << format_char( alphabet[(accum & 0x3)<<4] ) << "==";
        }
    }

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

Definition at line 15 of file bsearch.cpp.

                                                                                        {
        return bsearch_inline_t(p_count,p_callback,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

Definition at line 6 of file bsearch_inline.h.

{
    t_size max = p_count;
    t_size min = 0;
    t_size ptr;
    while(min<max)
    {
        ptr = min + ( (max-min) >> 1);
        int result = p_callback.test(ptr);
        if (result<0) min = ptr + 1;
        else if (result>0) max = ptr;
        else 
        {
            p_result = ptr;
            return true;
        }
    }
    p_result = min;
    return false;
}

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
	)

Definition at line 56 of file bsearch.h.

                                                                                                                                                                                {
        t_size index;
        if (bsearch(
            p_count,
            bsearch_callback_impl_permutation_t<t_container,t_compare,t_param,t_permutation>(p_container,p_compare,p_param,p_permutation),
            index))
        {
            p_index = p_permutation[index];
            return true;
        } else {
            return false;
        }
    }

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
	)

Definition at line 71 of file bsearch.h.

    {
        t_size probe;
        if (!bsearch(
            p_count,
            bsearch_callback_impl_simple_t<t_container,t_compare,t_param>(p_container,p_compare,p_param),
            probe)) return false;

        t_size base = probe, count = 1;
        while(base > 0 && p_compare(p_container[base-1],p_param) == 0) {base--; count++;}
        while(base + count < p_count && p_compare(p_container[base+count],p_param) == 0) {count++;}
        p_range_base = base;
        p_range_count = count;
        return true;
    }

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

Definition at line 28 of file bsearch_inline.h.

{
    t_size max = p_count;
    t_size min = 0;
    t_size ptr;
    while(min<max)
    {
        ptr = min + ( (max-min) >> 1);
        if (p_value > p_buffer[ptr]) min = ptr + 1;
        else if (p_value < p_buffer[ptr]) max = ptr;
        else 
        {
            p_result = ptr;
            return true;
        }
    }
    p_result = min;
    return false;
}

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
	)

Definition at line 48 of file bsearch.h.

                                                                                                                                {
        return bsearch(
            p_count,
            bsearch_callback_impl_simple_t<t_container,t_compare,t_param>(p_container,p_compare,p_param),
            p_index);
    }

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

inline

Definition at line 225 of file primitives.h.

                                                                       {
        if (!p_condition) {
            PFC_ASSERT(0);
            throw_exception_with_message<exception_bug_check>(p_msg);
        }
    }

void pfc::bug_check_assert ( bool  p_condition )

inline

Definition at line 232 of file primitives.h.

                                                   {
        if (!p_condition) {
            PFC_ASSERT(0);
            throw exception_bug_check();
        }
    }

template<typename T >

T pfc::byteswap_if_be_t

(

T

p_param

)

Definition at line 119 of file byte_order_helper.h.

{return byte_order_is_big_endian ? byteswap_t(p_param) : p_param;}

template<typename T >

T pfc::byteswap_if_le_t

(

T

p_param

)

Definition at line 120 of file byte_order_helper.h.

{return byte_order_is_little_endian ? byteswap_t(p_param) : p_param;}

template<typename T >

T pfc::byteswap_int_t

(

T

p_source

)

Definition at line 13 of file byte_order_helper.h.

                                                      {
        enum { width = sizeof(T) };
        typedef typename sized_int_t<width>::t_unsigned tU;
        tU in = p_source, out = 0;
        for(unsigned walk = 0; walk < width; ++walk) {
            out |= ((in >> (walk * 8)) & 0xFF) << ((width - 1 - walk) * 8);
        }
        return out;
    }

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

Definition at line 114 of file other.cpp.

                                                           {
    t_uint8 * ptr = (t_uint8*)p_buffer;
    t_size n;
    for(n=0;n<p_bytes>>1;n++) swap_t(ptr[n],ptr[p_bytes-n-1]);
}

template<typename T >

T pfc::byteswap_t

(

T

p_source

)

template<>

char pfc::byteswap_t< char > ( char  p_source )

inline

Definition at line 9 of file byte_order_helper.h.

{return p_source;}

template<>

double pfc::byteswap_t< double > ( double  p_source )

inline

Definition at line 59 of file byte_order_helper.h.

                                                                 {
        double ret;
        *(t_uint64*) &ret = byteswap_t(*(const t_uint64*)&p_source );
        return ret;
    }

template<>

float pfc::byteswap_t< float > ( float  p_source )

inline

Definition at line 53 of file byte_order_helper.h.

                                                              {
        float ret;
        *(t_uint32*) &ret = byteswap_t(*(const t_uint32*)&p_source );
        return ret;
    }

template<>

GUID pfc::byteswap_t< GUID > ( GUID  p_guid )

inline

Definition at line 66 of file byte_order_helper.h.

                                                         {
        GUID ret;
        ret.Data1 = pfc::byteswap_t(p_guid.Data1);
        ret.Data2 = pfc::byteswap_t(p_guid.Data2);
        ret.Data3 = pfc::byteswap_t(p_guid.Data3);
        ret.Data4[0] = p_guid.Data4[0];
        ret.Data4[1] = p_guid.Data4[1];
        ret.Data4[2] = p_guid.Data4[2];
        ret.Data4[3] = p_guid.Data4[3];
        ret.Data4[4] = p_guid.Data4[4];
        ret.Data4[5] = p_guid.Data4[5];
        ret.Data4[6] = p_guid.Data4[6];
        ret.Data4[7] = p_guid.Data4[7];
        return ret;
    }

template<>

int pfc::byteswap_t< int > ( int  p_source )

inline

Definition at line 29 of file byte_order_helper.h.

{return _byteswap_ulong(p_source);}

template<>

long pfc::byteswap_t< long > ( long  p_source )

inline

Definition at line 32 of file byte_order_helper.h.

{return _byteswap_ulong(p_source);}

template<>

long long pfc::byteswap_t< long long > ( long long  p_source )

inline

Definition at line 35 of file byte_order_helper.h.

{return _byteswap_uint64(p_source);}

template<>

short pfc::byteswap_t< short > ( short  p_source )

inline

Definition at line 26 of file byte_order_helper.h.

{return _byteswap_ushort(p_source);}

template<>

signed char pfc::byteswap_t< signed char > ( signed char  p_source )

inline

Definition at line 11 of file byte_order_helper.h.

{return p_source;}

template<>

unsigned char pfc::byteswap_t< unsigned char > ( unsigned char  p_source )

inline

Definition at line 10 of file byte_order_helper.h.

{return p_source;}

template<>

unsigned int pfc::byteswap_t< unsigned int > ( unsigned int  p_source )

inline

Definition at line 30 of file byte_order_helper.h.

{return _byteswap_ulong(p_source);}

template<>

unsigned long pfc::byteswap_t< unsigned long > ( unsigned long  p_source )

inline

Definition at line 33 of file byte_order_helper.h.

{return _byteswap_ulong(p_source);}

template<>

unsigned long long pfc::byteswap_t< unsigned long long > ( unsigned long long  p_source )

inline

Definition at line 36 of file byte_order_helper.h.

{return _byteswap_uint64(p_source);}

template<>

unsigned short pfc::byteswap_t< unsigned short > ( unsigned short  p_source )

inline

Definition at line 27 of file byte_order_helper.h.

{return _byteswap_ushort(p_source);}

template<>

wchar_t pfc::byteswap_t< wchar_t > ( wchar_t  p_source )

inline

Definition at line 24 of file byte_order_helper.h.

{return _byteswap_ushort(p_source);}

template<typename T >

t_size pfc::calc_array_width

(

t_size

p_width

)

Definition at line 26 of file alloc.h.

                                            {
        return pfc::mul_safe_t<std::bad_alloc,t_size>(p_width,sizeof(T));
    }

bool pfc::char_is_ascii_alpha ( char  p_char ) throw ( )

inline

Definition at line 103 of file string_base.h.

{return char_is_ascii_alpha_lower(p_char) || char_is_ascii_alpha_upper(p_char);}

bool pfc::char_is_ascii_alpha_lower ( char  p_char ) throw ( )

inline

Definition at line 102 of file string_base.h.

{return p_char >= 'a' && p_char <= 'z';}

bool pfc::char_is_ascii_alpha_upper ( char  p_char ) throw ( )

inline

Definition at line 101 of file string_base.h.

{return p_char >= 'A' && p_char <= 'Z';}

bool pfc::char_is_ascii_alphanumeric ( char  p_char ) throw ( )

inline

Definition at line 104 of file string_base.h.

{return char_is_ascii_alpha(p_char) || char_is_numeric(p_char);}

bool pfc::char_is_hexnumeric ( char  p_char ) throw ( )

inline

Definition at line 100 of file string_base.h.

{return char_is_numeric(p_char) || (p_char >= 'a' && p_char <= 'f') || (p_char >= 'A' && p_char <= 'F');}

template<typename char_t >

bool pfc::char_is_numeric ( char_t  p_char ) throw ( )

inline

Definition at line 99 of file string_base.h.

{return p_char >= '0' && p_char <= '9';}

unsigned pfc::char_to_dec

(

char

c

)

Definition at line 1078 of file string_base.cpp.

                             {
    if (c >= '0' && c <= '9') return (unsigned)(c - '0');
    else throw exception_invalid_params();
}

unsigned pfc::char_to_hex

(

char

c

)

Definition at line 1083 of file string_base.cpp.

                             {
    if (c >= '0' && c <= '9') return (unsigned)(c - '0');
    else if (c >= 'a' && c <= 'f') return (unsigned)(c - 'a' + 10);
    else if (c >= 'A' && c <= 'F') return (unsigned)(c - 'A' + 10);
    else throw exception_invalid_params();
}

t_uint32 pfc::charLower

(

uint32_t

param

)

Definition at line 1093 of file string_base.cpp.

{
    if (param<128) {
        return ascii_tolower_table[param];
    }
#ifdef _WIN32
    else if (param<0x10000) {
        return (unsigned)CharLowerW((WCHAR*)param);
    }
#endif
    else return param;
}

t_uint32 pfc::charUpper

(

uint32_t

param

)

Definition at line 1106 of file string_base.cpp.

{
    if (param<128) {
        if (param>='a' && param<='z') param += 'A' - 'a';
        return param;
    }
#ifdef _WIN32
    else if (param<0x10000) {
        return (unsigned)CharUpperW((WCHAR*)param);
    }
#endif
    else return param;
}

static bool pfc::check_end_of_string ( const char *  ptr )

static

Definition at line 290 of file utf8.cpp.

{
    return !*ptr;
}

template<typename T >

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

inline

Definition at line 565 of file primitives.h.

                                                                        {
        if (p_item < p_min) return p_min;
        else if (p_item <= p_max) return p_item;
        else return p_max;
    }

template<typename T >

T* pfc::clone_t ( T *  ptr )

inline

Definition at line 582 of file primitives.h.

{return new T(*ptr);}

template<>

int pfc::compare_t ( const hasher_md5_result &  p_item1, const hasher_md5_result &  p_item2  )

inline

Definition at line 20 of file hasher_md5.h.

                                                                                                          {
        return memcmp(&p_item1, &p_item2, sizeof(hasher_md5_result));
    }

template<typename t_item1 , typename t_item2 >

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

inline

Definition at line 336 of file primitives.h.

                                                                           {
        if (p_item1 < p_item2) return -1;
        else if (p_item1 > p_item2) return 1;
        else return 0;
    }

template<>

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

inline

Definition at line 21 of file guid.h.

{return guid_compare(p_item1,p_item2);}

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

Definition at line 272 of file string_base.cpp.

{
    t_size ptr = 0;
    PFC_ASSERT(replace>0);
    while(ptr<max && src[ptr])
    {
        unsigned c;
        t_size delta = utf8_decode_char(src+ptr,c,max-ptr);
        if (delta==0) {c = replace; delta = 1;}
        else if (c>=0x80) c = replace;
        *(out++) = (char)c;
        ptr += delta;
    }
    *out = 0;
}

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
	)

Definition at line 616 of file primitives.h.

                                                                             {
        for(t_size n=0;n<p_count;n++) p_dst[n] = p_src[n];
    }

template<typename t_to , typename t_from >

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

Definition at line 71 of file array.h.

                                                         {
        const t_size size = array_size_t(p_from);
        if (p_to.has_owned_items(p_from)) {//avoid landmines with actual array data overlapping, or p_from being same as p_to
            array_staticsize_t<typename t_to::t_item> temp;
            temp.set_size_discard(size);
            pfc::copy_array_loop_t(temp,p_from,size);
            p_to.set_size(size);
            pfc::copy_array_loop_t(p_to,temp,size);
        } else {
            p_to.set_size(size);
            pfc::copy_array_loop_t(p_to,p_from,size);
        }
    }

template<typename t_receiver , typename t_giver >

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

Definition at line 819 of file primitives.h.

                                                                               {
        p_receiver.remove_all();
        overwrite_list_enumerated(p_receiver,p_giver);
    }

unsigned pfc::countBits32 ( uint32_t  i )

inline

Definition at line 850 of file primitives.h.

                                            {
        const uint32_t mask = 0x11111111;
        uint32_t acc = i & mask;
        acc += (i >> 1) & mask;
        acc += (i >> 2) & mask;
        acc += (i >> 3) & mask;

        const uint32_t mask2 = 0x0F0F0F0F;
        uint32_t acc2 = acc & mask2;
        acc2 += (acc >> 4) & mask2;
    
        const uint32_t mask3 = 0x00FF00FF;
        uint32_t acc3 = acc2 & mask3;
        acc3 += (acc2 >> 8) & mask3;

        return (acc3 & 0xFFFF) + ((acc3 >> 16) & 0xFFFF);
    }

void pfc::crash

(

)

Definition at line 105 of file other.cpp.

                {
#ifdef _MSC_VER
    __debugbreak();
#else
    raise(SIGINT);
#endif
}

void pfc::create_move_items_permutation	(	t_size *	p_output,
		t_size	p_count,
		const class bit_array &	p_selection,
		int	p_delta
	)

Creates a permutation that moves selected items in a list box by the specified delta-offset.

void pfc::create_move_items_permutation	(	t_size *	p_output,
		t_size	p_count,
		const bit_array &	p_selection,
		int	p_delta
	)

Definition at line 31 of file other.cpp.

                                                                                                                   {
        t_size * const order = p_output;
        const t_size count = p_count;

        pfc::array_t<bool> selection; selection.set_size(p_count);
        
        for(t_size walk = 0; walk < count; ++walk) {
            order[walk] = walk;
            selection[walk] = p_selection[walk];
        }

        if (p_delta<0)
        {
            for(;p_delta<0;p_delta++)
            {
                t_size idx;
                for(idx=1;idx<count;idx++)
                {
                    if (selection[idx] && !selection[idx-1])
                    {
                        pfc::swap_t(order[idx],order[idx-1]);
                        pfc::swap_t(selection[idx],selection[idx-1]);
                    }
                }
            }
        }
        else
        {
            for(;p_delta>0;p_delta--)
            {
                t_size idx;
                for(idx=count-2;(int)idx>=0;idx--)
                {
                    if (selection[idx] && !selection[idx+1])
                    {
                        pfc::swap_t(order[idx],order[idx+1]);
                        pfc::swap_t(selection[idx],selection[idx+1]);
                    }
                }
            }
        }
    }

GUID pfc::createGUID

(

)

Definition at line 157 of file guid.cpp.

                      {
        GUID out;
#ifdef _WIN32
        if (FAILED(CoCreateGuid( & out ) ) ) crash();
#else
        pfc::nixGetRandomData( &out, sizeof(out) );
#endif
        return out;
    }

void pfc::createPipe	(	int	fd[2],
		bool	bInheritable
	)

Definition at line 39 of file nix-objects.cpp.

                                                    {
#if defined(__linux__) && defined(O_CLOEXEC)
        if (pipe2(fd, bInheritable ? 0 : O_CLOEXEC) < 0) throw exception_nix();
#else
        if (pipe(fd) < 0) throw exception_nix();
        if (!bInheritable) {
            setInheritable( fd[0], false );
            setInheritable( fd[1], false );
        }
#endif
    }

template<typename TInt >

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

inline

Definition at line 199 of file byte_order_helper.h.

                                                                         {
        p_out = __DecodeIntHelper<TInt,sizeof(TInt),true>::Run(p_buffer + (sizeof(TInt) - 1));
    }

template<typename TInt >

TInt pfc::decode_big_endian ( const t_uint8 *  p_buffer )

inline

Definition at line 211 of file byte_order_helper.h.

                                                            {
        TInt temp;
        decode_big_endian(temp,p_buffer);
        return temp;
    }

template<bool IsBigEndian, typename TInt >

void pfc::decode_endian ( TInt &  p_out, const t_uint8 *  p_buffer  )

inline

Definition at line 218 of file byte_order_helper.h.

                                                                     {
        if (IsBigEndian) decode_big_endian(p_out,p_buffer);
        else decode_little_endian(p_out,p_buffer);
    }

template<typename TInt >

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

inline

Definition at line 194 of file byte_order_helper.h.

                                                                            {
        p_out = __DecodeIntHelper<TInt,sizeof(TInt),false>::Run(p_buffer);
    }

template<typename TInt >

TInt pfc::decode_little_endian ( const t_uint8 *  p_buffer )

inline

Definition at line 204 of file byte_order_helper.h.

                                                               {
        TInt temp;
        decode_little_endian(temp,p_buffer);
        return temp;
    }

template<typename T >

void pfc::delete_array_t ( T *  ptr )

inline

Definition at line 579 of file primitives.h.

{delete[] ptr;}

template<typename T >

void pfc::delete_t ( T *  ptr )

inline

Definition at line 576 of file primitives.h.

{delete ptr;}

template<typename t_ret , typename t_param >

t_ret pfc::downcast_guarded

(

const t_param &

p_param

)

Definition at line 203 of file primitives.h.

                                                    {
        t_ret temp = (t_ret) p_param;
        if ((t_param) temp != p_param) throw exception_overflow();
        return temp;
    }

template<typename t_exception , typename t_ret , typename t_param >

t_ret pfc::downcast_guarded_ex

(

const t_param &

p_param

)

Definition at line 210 of file primitives.h.

                                                       {
        t_ret temp = (t_ret) p_param;
        if ((t_param) temp != p_param) throw t_exception();
        return temp;
    }

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

inline

Definition at line 239 of file primitives.h.

                                                                     {
        if (!p_condition) {
            PFC_ASSERT(0);
            throw_exception_with_message<exception_dynamic_assert>(p_msg);
        }
    }

void pfc::dynamic_assert ( bool  p_condition )

inline

Definition at line 245 of file primitives.h.

                                                 {
        if (!p_condition) {
            PFC_ASSERT(0);
            throw exception_dynamic_assert();
        }
    }

template<typename T >

const T* pfc::empty_string_t

(

)

template<>

const char* pfc::empty_string_t< char > ( )

inline

Definition at line 677 of file primitives.h.

{return "";}

template<>

const wchar_t* pfc::empty_string_t< wchar_t > ( )

inline

Definition at line 678 of file primitives.h.

{return L"";}

template<typename TInt >

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

inline

Definition at line 168 of file byte_order_helper.h.

                                                                   {
        __EncodeIntHelper<TInt,sizeof(TInt),true>::Run(p_value,p_buffer + (sizeof(TInt) - 1));
    }

template<bool IsBigEndian, typename TInt >

void pfc::encode_endian ( t_uint8 *  p_buffer, TInt  p_in  )

inline

Definition at line 223 of file byte_order_helper.h.

                                                            {
        if (IsBigEndian) encode_big_endian(p_in,p_buffer);
        else encode_little_endian(p_in,p_buffer);
    }

template<typename TInt >

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

inline

Definition at line 164 of file byte_order_helper.h.

                                                                      {
        __EncodeIntHelper<TInt,sizeof(TInt),false>::Run(p_value,p_buffer);
    }

double pfc::exp_int	(	double	base,
		int	exp
	)

Definition at line 143 of file other.cpp.

                                                       {
    //    return pow(base, (double)v);
    
    bool neg;
    unsigned exp;
    if (expS < 0) {
        neg = true;
        exp = (unsigned) -expS;
    } else {
        neg = false;
        exp = (unsigned) expS;
    }
    double v = 1.0;
    if (true) {
        if (exp) {
            double mul = base;
            for(;;) {
                if (exp & 1) v *= mul;
                exp >>= 1;
                if (exp == 0) break;
                mul *= mul;
            }
        }
    } else {
        for(unsigned i = 0; i < exp; ++i) {
            v *= base;
        }
    }
    if (neg) v = 1.0 / v;
    return v;
}

bool pfc::fdCanRead

(

int

fd

)

Definition at line 110 of file nix-objects.cpp.

                             {
        return fdWaitRead( fd, 0 );
    }

bool pfc::fdCanWrite

(

int

fd

)

Definition at line 113 of file nix-objects.cpp.

                              {
        return fdWaitWrite( fd, 0 );
    }

bool pfc::fdWaitRead	(	int	fd,
		double	timeOutSeconds
	)

Definition at line 117 of file nix-objects.cpp.

                                                     {
        fdSelect sel; sel.Reads += fd;
        return sel.Select( timeOutSeconds ) > 0;
    }

bool pfc::fdWaitWrite	(	int	fd,
		double	timeOutSeconds
	)

Definition at line 121 of file nix-objects.cpp.

                                                      {
        fdSelect sel; sel.Writes += fd;
        return sel.Select( timeOutSeconds ) > 0;
    }

void pfc::fileHandleClose

(

fileHandle_t

h

)

Definition at line 8 of file filehandle.cpp.

                                       {
    if (h == fileHandleInvalid) return;
#ifdef _WIN32
    CloseHandle( h );
#else
    close( h );
#endif
}

fileHandle_t pfc::fileHandleDup

(

fileHandle_t

h

)

Definition at line 17 of file filehandle.cpp.

                                             {
#ifdef _WIN32
    auto proc = GetCurrentProcess();
    HANDLE out;
    if (!DuplicateHandle ( proc, h, proc, &out, 0, FALSE, DUPLICATE_SAME_ACCESS )) return fileHandleInvalid;
    return out;
#else
    return dup( h );
#endif
}

uint64_t pfc::fileTimeNow

(

)

Definition at line 65 of file timers.cpp.

                           {
#ifdef _WIN32
        uint64_t ret;
        GetSystemTimeAsFileTime((FILETIME*)&ret);
        return ret;
#else
        return fileTimeUtoW(time(NULL));
#endif
    }

uint64_t pfc::fileTimeUtoW

(

uint64_t

ft

)

Definition at line 55 of file timers.cpp.

                                       {
        return (ft * 10000000) + 116444736000000000;
    }

uint64_t pfc::fileTimeUtoW

(

const timespec &

ts

)

Definition at line 59 of file timers.cpp.

                                               {
        uint64_t ft = (uint64_t)ts.tv_sec * 10000000 + (uint64_t)ts.tv_nsec / 100;
        return ft + 116444736000000000;
    }

uint64_t pfc::fileTimeWtoU

(

uint64_t

ft

)

Definition at line 52 of file timers.cpp.

                                       {
        return (ft - 116444736000000000 + /*rounding*/10000000/2) / 10000000;
    }

template<typename t_array , typename t_value >

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

Definition at line 86 of file array.h.

                                                                 {
        const t_size size = array_size_t(p_array);
        for(t_size n=0;n<size;n++) p_array[n] = p_value;
    }

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

Definition at line 330 of file primitives.h.

                                                                                               {
        for(t_size n=0;n<p_count;n++)
            p_buffer[n] = p_filler;
    }

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

Definition at line 324 of file primitives.h.

                                                                                           {
        for(t_size n=0;n<p_count;n++)
            p_buffer[n] = p_filler;
    }

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
	)

Definition at line 755 of file primitives.h.

                                                                                                                                                              {
        t_size ret = 0;
        t_size n;
        if (p_count > 0) {
            p_out.set(p_permutation[0],false);
            for(n=1;n<p_count;n++)
            {
                bool found = p_compare(p_array[p_permutation[n-1]],p_array[p_permutation[n]]) == 0;
                if (found) ret++;
                p_out.set(p_permutation[n],found);
            }
        }
        return ret;
    }

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
	)

Definition at line 738 of file primitives.h.

                                                                                                              {
        t_size ret = 0;
        t_size n;
        if (p_count > 0)
        {
            p_out.set(0,false);
            for(n=1;n<p_count;n++)
            {
                bool found = p_compare(p_array[n-1],p_array[n]) == 0;
                if (found) ret++;
                p_out.set(n,found);
            }
        }
        return ret;
    }

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

Definition at line 144 of file string_base.cpp.

                                                                                          {
    pfc::string_fixed_t<63> temp;
    t_size outptr;

    if (out_max == 0) return;
    out_max--;//for null terminator
    
    outptr = 0; 

    if (outptr == out_max) {out[outptr]=0;return;}

    if (val<0) {out[outptr++] = '-'; val = -val;}
    else if (b_sign) {out[outptr++] = '+';}

    if (outptr == out_max) {out[outptr]=0;return;}

    
    {
        double powval = pow((double)10.0,(double)precision);
        temp << (t_int64)floor(val * powval + 0.5);
        //_i64toa(blargh,temp,10);
    }
    
    const t_size temp_len = temp.length();
    if (temp_len <= precision)
    {
        out[outptr++] = '0';
        if (outptr == out_max) {out[outptr]=0;return;}
        out[outptr++] = '.';
        if (outptr == out_max) {out[outptr]=0;return;}
        t_size d;
        for(d=precision-temp_len;d;d--)
        {
            out[outptr++] = '0';
            if (outptr == out_max) {out[outptr]=0;return;}
        }
        for(d=0;d<temp_len;d++)
        {
            out[outptr++] = temp[d];
            if (outptr == out_max) {out[outptr]=0;return;}
        }
    }
    else
    {
        t_size d = temp_len;
        const char * src = temp;
        while(*src)
        {
            if (d-- == precision)
            {
                out[outptr++] = '.';
                if (outptr == out_max) {out[outptr]=0;return;}
            }
            out[outptr++] = *(src++);
            if (outptr == out_max) {out[outptr]=0;return;}
        }
    }
    out[outptr] = 0;
}

char pfc::format_hex_char

(

unsigned

p_val

)

Definition at line 513 of file string_base.cpp.

{
    PFC_ASSERT(p_val < 16);
    return (p_val < 10) ? p_val + '0' : p_val - 10 + 'A';
}

char pfc::format_hex_char_lowercase

(

unsigned

p_val

)

Definition at line 541 of file string_base.cpp.

{
    PFC_ASSERT(p_val < 16);
    return (p_val < 10) ? p_val + '0' : p_val - 10 + 'a';
}

t_size pfc::getOptimalWorkerThreadCount

(

)

Definition at line 17 of file threads.cpp.

                                         {
#ifdef _WINDOWS
        DWORD_PTR mask,system;
        t_size ret = 0;
        GetProcessAffinityMask(GetCurrentProcess(),&mask,&system);
        for(t_size n=0;n<sizeof(mask)*8;n++) {
            if (mask & ((DWORD_PTR)1<<n)) ret++;
        }
        if (ret == 0) return 1;
        return ret;
#elif defined(__ANDROID__)
                return android_getCpuCount();
#else
        return std::thread::hardware_concurrency();
#endif


#if 0 // OSX
        size_t len;
        unsigned int ncpu;
        
        len = sizeof(ncpu);
        sysctlbyname ("hw.ncpu",&ncpu,&len,NULL,0);
        
        return ncpu;
#endif
    }

t_size pfc::getOptimalWorkerThreadCountEx

(

t_size

taskCountLimit

)

Definition at line 45 of file threads.cpp.

                                                                {
        if (taskCountLimit <= 1) return 1;
        return pfc::min_t(taskCountLimit,getOptimalWorkerThreadCount());
    }

template<typename t_list1 , typename t_list2 >

static bool pfc::guess_reorder_pattern ( pfc::array_t< t_size > &  out, const t_list1 &  from, const t_list2 &  to  )

static

Definition at line 3 of file primitives_part2.h.

                                                                                                          {
        typedef typename t_list1::t_item t_item;
        const t_size count = from.get_size();
        if (count != to.get_size()) return false;
        out.set_size(count);
        for(t_size walk = 0; walk < count; ++walk) out[walk] = walk;
        //required output: to[n] = from[out[n]];
        typedef pfc::chain_list_v2_t<t_size> t_queue;
        pfc::map_t<t_item, t_queue > content;
        for(t_size walk = 0; walk < count; ++walk) {
            content.find_or_add(from[walk]).add_item(walk);
        }
        for(t_size walk = 0; walk < count; ++walk) {
            t_queue * q = content.query_ptr(to[walk]);
            if (q == NULL) return false;
            if (q->get_count() == 0) return false;
            out[walk] = *q->first();
            q->remove(q->first());
        }
        return true;
    }

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

inline

Definition at line 18 of file guid.h.

{return memcmp(&g1,&g2,sizeof(GUID));}

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

inline

Definition at line 20 of file guid.h.

{return (g1 == g2) ? true : false;}

GUID pfc::GUID_from_text

(

const char *

text

)

Definition at line 102 of file guid.cpp.

                                       {
    return _GUID_from_text( text );
}

bool pfc::has_path_bad_chars

(

const char *

param

)

Definition at line 134 of file string_base.cpp.

{
    while(*param)
    {
        if (is_path_bad_char(*param)) return true;
        param++;
    }
    return false;
}

template<typename t_ret >

t_ret pfc::implicit_cast

(

t_ret

val

)

Definition at line 182 of file primitives.h.

{return val;}

double pfc::importTimeval

(

const timeval &

in

)

Definition at line 69 of file nix-objects.cpp.

                                             {
        return (double)in.tv_sec + (double)in.tv_usec / 1000000.0;
    }

template<typename array1_t , typename array2_t >

void pfc::insert_array_t	(	array1_t &	outArray,
		size_t	insertAt,
		array2_t const &	inArray,
		size_t	inArraySize
	)

Definition at line 510 of file primitives.h.

                                                                                                             {
        const size_t oldSize = outArray.get_size();
        if (insertAt > oldSize) insertAt = oldSize;
        const size_t newSize = oldSize + inArraySize;
        outArray.set_size( newSize );
        for(size_t m = oldSize; m != insertAt; --m) {
            move_t( outArray[ m - 1 + inArraySize], outArray[m - 1] );
        }
        for(size_t w = 0; w < inArraySize; ++w) {
            outArray[ insertAt + w ]  = inArray[ w ];
        }
    }

template<typename t_array , typename in_array_t >

t_size pfc::insert_multi_t ( t_array &  p_array, const in_array_t &  p_items, size_t  p_itemCount, t_size  p_index  )

inline

Definition at line 524 of file primitives.h.

                                                                                                                   {
        const t_size old_count = p_array.get_size();
        const size_t new_count = old_count + p_itemCount;
        if (p_index > old_count) p_index = old_count;
        p_array.set_size(new_count);
        size_t toMove = old_count - p_index;
        for(size_t w = 0; w < toMove; ++w) {
            move_t( p_array[new_count - 1 - w], p_array[old_count - 1 - w] );
        }
        
        for(size_t w = 0; w < p_itemCount; ++w) {
            p_array[p_index+w] = p_items[w];
        }

        return p_index;
    }

template<typename t_array , typename T >

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

inline

Definition at line 541 of file primitives.h.

                                                                             {
        t_size old_count = p_array.get_size();
        if (p_index > old_count) p_index = old_count;
        p_array.set_size(old_count + 1);
        for(t_size n=old_count;n>p_index;n--)
            swap_t(p_array[n],p_array[n-1]);
        swap_t(p_array[p_index],p_item);
        return p_index;
    }

template<typename t_array , typename T >

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

inline

Definition at line 500 of file primitives.h.

                                                                              {
        t_size old_count = p_array.get_size();
        if (p_index > old_count) p_index = old_count;
        p_array.set_size(old_count + 1);
        for(t_size n=old_count;n>p_index;n--)
            move_t(p_array[n], p_array[n-1]);
        p_array[p_index] = p_item;
        return p_index;
    }

template<typename t_array >

t_size pfc::insert_uninitialized_t ( t_array &  p_array, t_size  p_index  )

inline

Definition at line 491 of file primitives.h.

                                                                           {
        t_size old_count = p_array.get_size();
        if (p_index > old_count) p_index = old_count;
        p_array.set_size(old_count + 1);
        for(t_size n=old_count;n>p_index;n--) move_t(p_array[n], p_array[n-1]);
        return p_index;
    }

bool pfc::is_lower_ascii

(

const char *

param

)

Definition at line 280 of file utf8.cpp.

{
    while(*param)
    {
        if (*param<0) return false;
        param++;
    }
    return true;
}

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

Definition at line 809 of file string_base.cpp.

                                                      {
    for(t_size n = 0; n < p_len && p_string[n]; n++) {
        switch(p_string[n]) {
        case '\r':
        case '\n':
            return true;
        }
    }
    return false;
}

bool pfc::is_path_bad_char

(

unsigned

c

)

Definition at line 64 of file string_base.cpp.

{
#ifdef _WINDOWS
    return c=='\\' || c=='/' || c=='|' || c==':' || c=='*' || c=='?' || c=='\"' || c=='>' || c=='<';
#else
    return c=='/' || c=='*' || c=='?';
#endif
}

bool pfc::is_path_separator

(

unsigned

c

)

Definition at line 59 of file string_base.cpp.

{
    return c=='\\' || c=='/' || c=='|' || 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
	)

Definition at line 84 of file alloc.h.

                                                                                                  {
        return p_pointer >= reinterpret_cast<const void*>(p_buffer) && p_pointer < reinterpret_cast<const void*>(p_buffer + p_buffer_size);
    }

template<t_size p_size_pow2>

bool pfc::is_ptr_aligned_t ( const void *  p_ptr )

inline

Definition at line 695 of file primitives.h.

                                                     {
        static_assert_t< (p_size_pow2 & (p_size_pow2 - 1)) == 0 >();
        return ( ((t_size)p_ptr) & (p_size_pow2-1) ) == 0;
    }

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

Definition at line 264 of file utf8.cpp.

                                                  {
    t_size walk = 0;
    while(walk < max && param[walk] != 0) {
        t_size d;
        unsigned dummy;
        d = utf8_decode_char(param + walk,dummy,max - walk);
        if (d==0) return false;
        walk += d;
        if (walk > max) {
            PFC_ASSERT(0);//should not be triggerable
            return false;
        }
    }
    return true;
}

bool pfc::isAltKeyPressed

(

)

Definition at line 46 of file obj-c.mm.

                           {
#if TARGET_OS_MAC && !TARGET_OS_IPHONE
        return ( [NSEvent modifierFlags] & NSAlternateKeyMask ) != 0;
#else
        return false;
#endif
    }

bool pfc::isCtrlKeyPressed

(

)

Definition at line 39 of file obj-c.mm.

                            {
#if TARGET_OS_MAC && !TARGET_OS_IPHONE
        return ( [NSEvent modifierFlags] & NSControlKeyMask ) != 0;
#else
        return false;
#endif
    }

bool pfc::isShiftKeyPressed

(

)

Definition at line 32 of file obj-c.mm.

                             {
#if TARGET_OS_MAC && !TARGET_OS_IPHONE
        return ( [NSEvent modifierFlags] & NSShiftKeyMask ) != 0;
#else
        return false;
#endif
    }

template<typename t_list , typename t_array >

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

Definition at line 796 of file primitives.h.

                                                                {
        p_array.set_size(p_list.get_count());
        __list_to_array_enumerator<t_array> enumerator(p_array);
        p_list.enumerate(enumerator);
        enumerator.finalize();
    }

template<typename t_list1 , typename t_list2 >

static bool pfc::listEquals ( const t_list1 &  p_list1, const t_list2 &  p_list2  )

static

Definition at line 105 of file iterators.h.

                                                                             {
        typename t_list1::const_iterator iter1 = p_list1.first();
        typename t_list2::const_iterator iter2 = p_list2.first();
        for(;;) {
            if (iter1.is_empty() && iter2.is_empty()) return true;
            else if (iter1.is_empty() || iter2.is_empty()) return false;
            else if (*iter1 != *iter2) return false;
            ++iter1; ++iter2;
        }
    }

bool pfc::lxor ( bool  p_val1, bool  p_val2  )

inline

Definition at line 824 of file primitives.h.

                                              {
        return p_val1 == !p_val2;
    }

GUID pfc::makeGUID ( t_uint32  Data1, t_uint16  Data2, t_uint16  Data3, t_uint8  Data4_1, t_uint8  Data4_2, t_uint8  Data4_3, t_uint8  Data4_4, t_uint8  Data4_5, t_uint8  Data4_6, t_uint8  Data4_7, t_uint8  Data4_8  )

inline

Definition at line 27 of file guid.h.

                                                                                                                                                                                                                 {
        GUID guid = { Data1, Data2, Data3, {Data4_1, Data4_2, Data4_3, Data4_4, Data4_5, Data4_6, Data4_7, Data4_8 } };
        return guid;
    }

timeval pfc::makeTimeVal

(

double

timeSeconds

)

Definition at line 62 of file nix-objects.cpp.

                                              {
        timeval tv = {};
        uint64_t temp = (uint64_t) floor( timeSeconds * 1000000.0 + 0.5);
        tv.tv_usec = (uint32_t) (temp % 1000000);
        tv.tv_sec = (uint32_t) (temp / 1000000);
        return tv;
    }

template<typename t_val >

void pfc::max_acc ( t_val &  p_acc, const t_val &  p_val  )

inline

Definition at line 834 of file primitives.h.

                                                           {
        if (p_val > p_acc) p_acc = p_val;
    }

template<typename T >

T pfc::max_t ( const T &  item1, const T &  item2  )

inline

Definition at line 553 of file primitives.h.

{return item1 > item2 ? item1 : item2;};

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
	)

Definition at line 621 of file primitives.h.

                                                                              {
        p_dst += p_count; p_src += p_count;
        for(t_size n=0;n<p_count;n++) *(--p_dst) = *(--p_src);
    }

template<typename t_src , typename t_dst >

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

Definition at line 611 of file primitives.h.

                                                                  {
        for(t_size n=0;n<p_count;n++) p_dst[n] = p_src[n];
    }

template<typename T >

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

Definition at line 649 of file primitives.h.

                                                           {
        if (p_dst == p_src) {/*do nothing*/}
        else if (p_dst > p_src && p_dst < p_src + p_count) memcpy_backwards_t<T>(p_dst,p_src,p_count);
        else memcpy_t<T>(p_dst,p_src,p_count);
    }

template<typename T >

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

Definition at line 638 of file primitives.h.

                                                    {
        for(t_size n=0;n<p_count;n++) p_buffer[n] = 0;
    }

template<typename T >

void pfc::memset_null_t

(

T &

p_buffer

)

Definition at line 643 of file primitives.h.

                                    {
        const t_size width = pfc::array_size_t(p_buffer);
        for(t_size n=0;n<width;n++) p_buffer[n] = 0;
    }

template<typename T , typename t_val >

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

Definition at line 627 of file primitives.h.

                                                                   {
        for(t_size n=0;n<p_count;n++) p_buffer[n] = p_val;
    }

template<typename T , typename t_val >

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

Definition at line 632 of file primitives.h.

                                                   {
        const t_size width = pfc::array_size_t(p_buffer);
        for(t_size n=0;n<width;n++) p_buffer[n] = p_val;
    }

static void pfc::memxor ( void *  target, const void *  source1, const void *  source2, t_size  size  )

static

Definition at line 658 of file primitives.h.

                                                                                               {
        memxor_t( reinterpret_cast<t_uint8*>(target), reinterpret_cast<const t_uint8*>(source1), reinterpret_cast<const t_uint8*>(source2), size);
    }

template<typename TVal >

void pfc::memxor_t	(	TVal *	out,
		const TVal *	s1,
		const TVal *	s2,
		t_size	count
	)

Definition at line 655 of file primitives.h.

                                                                                                      {
        for(t_size walk = 0; walk < count; ++walk) out[walk] = s1[walk] ^ s2[walk];
    }

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
	)

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

Definition at line 443 of file primitives.h.

                                                                                                                    {
        p_destination.set_size(merge_sorted_lists_calculate_count(p_source1,p_source2));
        t_size walk1 = 0, walk2 = 0, walk_out = 0;
        const t_size max1 = p_source1.get_size(), max2 = p_source2.get_size();
        for(;;) {
            int state;
            if (walk1 < max1 && walk2 < max2) {
                state = pfc::compare_t(p_source1[walk1],p_source2[walk2]);
            } else if (walk1 < max1) {
                state = -1;
            } else if (walk2 < max2) {
                state = 1;
            } else {
                break;
            }
            if (state < 0) {
                p_destination[walk_out] = p_source1[walk1++];
            } else if (state > 0) {
                p_destination[walk_out] = p_source2[walk2++];
            } else {
                p_destination[walk_out] = p_source1[walk1];
                walk1++; walk2++;
            }
            walk_out++;
        }
    }

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
	)

Definition at line 419 of file primitives.h.

                                                                                                        {
        t_size walk1 = 0, walk2 = 0, walk_out = 0;
        const t_size max1 = p_source1.get_size(), max2 = p_source2.get_size();
        for(;;) {
            int state;
            if (walk1 < max1 && walk2 < max2) {
                state = pfc::compare_t(p_source1[walk1],p_source2[walk2]);
            } else if (walk1 < max1) {
                state = -1;
            } else if (walk2 < max2) {
                state = 1;
            } else {
                break;
            }
            if (state <= 0) walk1++;
            if (state >= 0) walk2++;
            walk_out++;
        }
        return walk_out;
    }

template<typename t_val >

void pfc::min_acc ( t_val &  p_acc, const t_val &  p_val  )

inline

Definition at line 829 of file primitives.h.

                                                           {
        if (p_val < p_acc) p_acc = p_val;
    }

template<typename T >

T pfc::min_t ( const T &  item1, const T &  item2  )

inline

Definition at line 556 of file primitives.h.

{return item1 < item2 ? item1 : item2;};

template<typename T >

void pfc::move_t ( T &  p_item1, T &  p_item2  )

inline

This is similar to plain p_item1 = p_item2; assignment, but optimized for the case where p_item2 content is no longer needed later on. This can be overridden for specific classes for optimal performance.
p_item2 value is undefined after performing a move_t. For an example, in certain cases move_t will fall back to swap_t.

Definition at line 298 of file primitives.h.

                                                 {
        typedef traits_t<T> t;
        if (t::needs_constructor || t::needs_destructor) {
            if (t::realloc_safe) swap_t(p_item1, p_item2);
            else p_item1 = std::move( p_item2 );
        } else {
            p_item1 = std::move( p_item2 );
        }
    }

template<typename t_exception , typename t_int >

t_int pfc::mul_safe_t ( t_int  p_val1, t_int  p_val2  )

inline

Definition at line 586 of file primitives.h.

                                                       {
        if (p_val1 == 0 || p_val2 == 0) return 0;
        t_int temp = (t_int) (p_val1 * p_val2);
        if (temp / p_val1 != p_val2) throw t_exception();
        return temp;
    }

template<typename t_int >

t_int pfc::multiply_guarded	(	t_int	v1,
		t_int	v2
	)

Definition at line 593 of file primitives.h.

                                               {
        return mul_safe_t<exception_overflow>(v1, v2);
    }

void pfc::myassert	(	const wchar_t *	_Message,
		const wchar_t *	_File,
		unsigned	_Line
	)

Definition at line 121 of file other.cpp.

                                                                                 { 
    if (IsDebuggerPresent()) pfc::crash();
    _wassert(_Message,_File,_Line);
}

static t_size pfc::myrand ( t_size  count )

static

Definition at line 151 of file sort.cpp.

                                   {
    const uint64_t rm = RAND_MAX + 1;
    uint64_t m = 1;
    uint64_t v = 0;
    for(;;) {
        v += rand() * m;
        m *= rm;
        if (m >= count) break;
    }
    v ^= uniqueVal();
    return (t_size)(v % count);
}

int pfc::naturalSortCompare	(	const char *	s1,
		const char *	s2
	)
throw	(
	)

Definition at line 489 of file string_base.cpp.

                                                                  {
    int v = naturalSortCompareInternal( s1, s2, true );
    if (v) return v;
    v = naturalSortCompareInternal( s1, s2, false );
    if (v) return v;
    return strcmp(s1, s2);
}

int pfc::naturalSortCompareI	(	const char *	s1,
		const char *	s2
	)
throw	(
	)

Definition at line 497 of file string_base.cpp.

                                                                   {
    return naturalSortCompareInternal( s1, s2, true );
}

static int pfc::naturalSortCompareInternal ( const char *  s1, const char *  s2, bool  insensitive  ) throw ( )

static

Definition at line 438 of file string_base.cpp.

                                                                                                   {
    for( ;; ) {
        unsigned c1, c2;
        size_t d1 = utf8_decode_char( s1, c1 );
        size_t d2 = utf8_decode_char( s2, c2 );
        if (d1 == 0 && d2 == 0) {
            return 0;
        }
        if (char_is_numeric( c1 ) && char_is_numeric( c2 ) ) {
            // Numeric block in both strings, do natural sort magic here
            size_t l1 = 1, l2 = 1;
            while( char_is_numeric( s1[l1] ) ) ++l1;
            while( char_is_numeric( s2[l2] ) ) ++l2;
            
            size_t l = max_t(l1, l2);
            for(size_t w = 0; w < l; ++w) {
                char digit1, digit2;
                
                t_ssize off;
                
                off = w + l1 - l;
                if (off >= 0) {
                    digit1 = s1[w - l + l1];
                } else {
                    digit1 = 0;
                }
                off = w + l2 - l;
                if (off >= 0) {
                    digit2 = s2[w - l + l2];
                } else {
                    digit2 = 0;
                }
                if (digit1 < digit2) return -1;
                if (digit1 > digit2) return 1;
            }
            
            s1 += l1; s2 += l2;
            continue;
        }
        

        if (insensitive) {
            c1 = charLower( c1 );
            c2 = charLower( c2 );
        }
        if (c1 < c2) return -1;
        if (c1 > c2) return 1;
        
        s1 += d1; s2 += d2;
    }
}

template<typename T >

T* pfc::new_ptr_check_t

(

T *

p_ptr

)

Definition at line 663 of file primitives.h.

                                 {
        if (p_ptr == NULL) throw std::bad_alloc();
        return p_ptr;
    }

static void pfc::newsort ( pfc::sort_callback &  p_callback, t_size const  p_base, t_size const  p_count  )

static

Definition at line 183 of file sort.cpp.

                                                                                            {
    if (p_count <= 4) {
        squaresort(p_callback,p_base,p_count);
        return;
    }

    t_size pivot = __pivot_helper(p_callback,p_base,p_count);

    {
        const t_size target = p_base + p_count - 1;
        if (pivot != target) {
            p_callback.swap(pivot,target); pivot = target;
        }
    }


    t_size partition = p_base;
    {
        bool asdf = false;
        for(t_size walk = p_base; walk < pivot; ++walk) {
            const int comp = p_callback.compare(walk,pivot);
            bool trigger = false;
            if (comp == 0) {
                trigger = asdf;
                asdf = !asdf;
            } else if (comp < 0) {
                trigger = true;
            }
            if (trigger) {
                if (partition != walk) p_callback.swap(partition,walk);
                partition++;
            }
        }
    }   
    if (pivot != partition) {
        p_callback.swap(pivot,partition); pivot = partition;
    }

    newsort(p_callback,p_base,pivot-p_base);
    newsort(p_callback,pivot+1,p_count-(pivot+1-p_base));
}

void pfc::nixFormatError	(	string_base &	str,
		int	code
	)

Definition at line 13 of file nix-objects.cpp.

                                                       {
        char buffer[512] = {};
        strerror_r(code, buffer, sizeof(buffer));
        str = buffer;
    }

void pfc::nixGetRandomData	(	void *	outPtr,
		size_t	outBytes
	)

Definition at line 211 of file nix-objects.cpp.

                                                            {
        fileHandle randomData;
        randomData = open("/dev/random", O_RDONLY);
        if (randomData.h < 0) throw exception_nix();
        if ( read( randomData.h, outPtr, outBytes ) != outBytes ) throw exception_nix();
    }

double pfc::nixGetTime

(

)

Definition at line 178 of file nix-objects.cpp.

                        {
        timeval tv = {};
        gettimeofday(&tv, NULL);
        return importTimeval(tv);
    }

bool pfc::nixReadSymLink	(	string_base &	strOut,
		const char *	path
	)

Definition at line 184 of file nix-objects.cpp.

                                                                   {
        size_t l = 1024;
        for(;;) {
            array_t<char> buffer; buffer.set_size( l + 1 );
            ssize_t rv = (size_t) readlink(path, buffer.get_ptr(), l);
            if (rv < 0) return false;
            if ((size_t)rv <= l) {
                buffer.get_ptr()[rv] = 0;
                strOut = buffer.get_ptr();
                return true;
            }
            l *= 2;
        }
    }

bool pfc::nixSelfProcessPath

(

string_base &

strOut

)

Definition at line 198 of file nix-objects.cpp.

                                                    {
#ifdef __APPLE__
        uint32_t len = 0;
        _NSGetExecutablePath(NULL, &len);
        array_t<char> temp; temp.set_size( len + 1 ); temp.fill_null();
        _NSGetExecutablePath(temp.get_ptr(), &len);
        strOut = temp.get_ptr();
        return true;
#else
        return nixReadSymLink( strOut, PFC_string_formatter() << "/proc/" << (unsigned) getpid() << "/exe");
#endif
    }

void pfc::nixSleep

(

double

seconds

)

Definition at line 174 of file nix-objects.cpp.

                                  {
        fdSelect sel; sel.Select( seconds );
    }

template<typename t_receiver , typename t_giver >

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

Definition at line 813 of file primitives.h.

                                                                                    {
        enumerator_add_item<t_receiver> wrapper(p_receiver);
        p_giver.enumerate(wrapper);
    }

double pfc::parse_timecode

(

const char *

in

)

Definition at line 849 of file string_base.cpp.

                                       {
    char separator = 0;
    uint64_t seconds = 0;
    unsigned colons = 0;
    for (;;) {
        uint64_t number = 0;
        size_t digits = parseNumber(in, number);
        if (digits == 0) throw pfc::exception_invalid_params();
        in += digits;
        char nextSeparator = *in;
        switch (separator) { // *previous* separator
        case '.':
            if (nextSeparator != 0) throw pfc::exception_bug_check();
            return (double)seconds + (double)pfc::exp_int(10, -(int)digits) * number;
        case 0: // is first number in the string
            seconds = number;
            break;
        case ':':
            if (colons == 2) throw pfc::exception_invalid_params();
            ++colons;
            seconds = safeMulAdd(seconds, 60, number);
            break;
        }

        if (nextSeparator == 0) {
            // end of string
            return (double)seconds;
        }

        ++in;
        separator = nextSeparator;
    }
}

static size_t pfc::parseNumber ( const char *  in, uint64_t &  outNumber  )

static

Definition at line 833 of file string_base.cpp.

                                                                 {
    size_t walk = 0;
    uint64_t total = 0;
    for (;;) {
        char c = in[walk];
        if (!pfc::char_is_numeric(c)) break;
        unsigned v = (unsigned)(c - '0');
        uint64_t newVal = total * 10 + v;
        if (newVal / 10 != total) throw pfc::exception_overflow();
        total = newVal;
        ++walk;
    }
    outNumber = total;
    return walk;
}

t_size pfc::permutation_find_reverse	(	t_size const *	order,
		t_size	count,
		t_size	value
	)

Definition at line 23 of file other.cpp.

                                                                                      {
        if (value >= count) return ~0;
        for(t_size walk = 0; walk < count; ++walk) {
            if (order[walk] == value) return walk;
        }
        return ~0;
    }

bool pfc::permutation_is_valid	(	t_size const *	order,
		t_size	count
	)

For critical sanity checks. Speed: O(n), allocates memory.

Definition at line 10 of file other.cpp.

                                                                  {
        bit_array_bittable found(count);
        for(t_size walk = 0; walk < count; ++walk) {
            if (order[walk] >= count) return false;
            if (found[walk]) return false;
            found.set(walk,true);
        }
        return true;
    }

void pfc::permutation_validate	(	t_size const *	order,
		t_size	count
	)

For critical sanity checks. Speed: O(n), allocates memory.

Definition at line 19 of file other.cpp.

                                                                  {
        if (!permutation_is_valid(order,count)) throw exception_invalid_permutation();
    }

pfc::PFC_DECLARE_EXCEPTION	(	exception_invalid_permutation	,
		exception_invalid_params	,
		"Invalid permutation"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_map_entry_not_found	,
		exception	,
		"Map entry not found"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_overflow	,
		exception	,
		"Overflow"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_bug_check	,
		exception	,
		"Bug check"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_invalid_params	,
		exception_bug_check	,
		"Invalid parameters"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_unexpected_recursion	,
		exception_bug_check	,
		"Unexpected recursion"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_not_implemented	,
		exception_bug_check	,
		"Feature not implemented"
	)

pfc::PFC_DECLARE_EXCEPTION	(	exception_dynamic_assert	,
		exception_bug_check	,
		"dynamic_assert failure"
	)

static double pfc::pfc_string_to_float_internal ( const char *  src )

static

Definition at line 206 of file string_base.cpp.

{
    bool neg = false;
    t_int64 val = 0;
    int div = 0;
    bool got_dot = false;

    while(*src==' ') src++;

    if (*src=='-') {neg = true;src++;}
    else if (*src=='+') src++;
    
    while(*src)
    {
        if (*src>='0' && *src<='9')
        {
            int d = *src - '0';
            val = val * 10 + d;
            if (got_dot) div--;
            src++;
        }
        else if (*src=='.' || *src==',')
        {
            if (got_dot) break;
            got_dot = true;
            src++;
        }
        else if (*src=='E' || *src=='e')
        {
            src++;
            div += atoi(src);
            break;
        }
        else break;
    }
    if (neg) val = -val;
    return (double) val * exp_int(10, div);
}

static t_uint64 pfc::pow10_helper ( unsigned  p_extra )

static

Definition at line 820 of file string_base.cpp.

                                               {
    t_uint64 ret = 1;
    for(unsigned n = 0; n < p_extra; n++ ) ret *= 10;
    return ret;
}

t_uint64 pfc::pow_int	(	t_uint64	base,
		t_uint64	exp
	)

Definition at line 128 of file other.cpp.

                                                 {
    t_uint64 mul = base;
    t_uint64 val = 1;
    t_uint64 mask = 1;
    while(exp != 0) {
        if (exp & mask) {
            val *= mul;
            exp ^= mask;
        }
        mul = mul * mul;
        mask <<= 1;
    }
    return val;
}

static void pfc::print_hex ( unsigned  val, char *&  out, unsigned  bytes  )

static

Definition at line 113 of file guid.cpp.

{
    unsigned n;
    for(n=0;n<bytes;n++)
    {
        unsigned char c = (unsigned char)((val >> ((bytes - 1 - n) << 3)) & 0xFF);
        *(out++) = print_hex_digit( c >> 4 );
        *(out++) = print_hex_digit( c & 0xF );
    }
    *out = 0;
}

static char pfc::print_hex_digit ( unsigned  val )

inlinestatic

Definition at line 106 of file guid.cpp.

{
    static const char table[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    assert((val & ~0xF) == 0);
    return table[val];
}

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

Definition at line 148 of file guid.cpp.

{
    char * out = p_out;
    const unsigned char * in = (const unsigned char *) buffer;
    unsigned n;
    for(n=0;n<bytes;n++)
        print_hex(in[n],out,1);
}

bool pfc::query_cpu_feature_set

(

unsigned

p_value

)

Definition at line 7 of file cpuid.cpp.

                                                 {
#ifdef _MSC_VER
        __try {
#endif
            if (p_value & (CPU_HAVE_SSE | CPU_HAVE_SSE2 | CPU_HAVE_SSE3 | CPU_HAVE_SSSE3 | CPU_HAVE_SSE41 | CPU_HAVE_SSE42)) {
                int buffer[4];
                __cpuid(buffer,1);
                if (p_value & CPU_HAVE_SSE) {
                    if ((buffer[3]&(1<<25)) == 0) return false;
                }
                if (p_value & CPU_HAVE_SSE2) {
                    if ((buffer[3]&(1<<26)) == 0) return false;
                }
                if (p_value & CPU_HAVE_SSE3) {
                    if ((buffer[2]&(1<<0)) == 0) return false;
                }
                if (p_value & CPU_HAVE_SSSE3) {
                    if ((buffer[2]&(1<<9)) == 0) return false;
                }
                if (p_value & CPU_HAVE_SSE41) {
                    if ((buffer[2]&(1<<19)) == 0) return false;
                }
                if (p_value & CPU_HAVE_SSE42) {
                    if ((buffer[2]&(1<<20)) == 0) return false;
                }
            }
    #ifdef _M_IX86
            if (p_value & (CPU_HAVE_3DNOW_EX | CPU_HAVE_3DNOW)) {
                int buffer_amd[4];
                __cpuid(buffer_amd,0x80000000);
                if ((unsigned)buffer_amd[0] < 0x80000001) return false;
                __cpuid(buffer_amd,0x80000001);
            
                if (p_value & CPU_HAVE_3DNOW) {
                    if ((buffer_amd[3]&(1<<31)) == 0) return false;
                }
                if (p_value & CPU_HAVE_3DNOW_EX) {
                    if ((buffer_amd[3]&(1<<30)) == 0) return false;
                }
            }
    #endif
            return true;
#ifdef _MSC_VER
        } __except(1) {
            return false;
        }
#endif
    }

static void pfc::raw_free ( void *  p_block ) throw ( )

static

Definition at line 7 of file alloc.h.

{free(p_block);}

static void* pfc::raw_malloc ( t_size  p_size )

static

Definition at line 3 of file alloc.h.

                                            {
        return p_size > 0 ? new_ptr_check_t(malloc(p_size)) : NULL;
    }

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

static

Definition at line 9 of file alloc.h.

                                                         {
        if (p_size == 0) {raw_free(p_ptr); return NULL;}
        else if (p_ptr == NULL) return raw_malloc(p_size);
        else return pfc::new_ptr_check_t(::realloc(p_ptr,p_size));
    }

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

static

Definition at line 15 of file alloc.h.

                                                                          {
        if (p_block == NULL) return p_size == 0;
#ifdef _MSC_VER
        if (p_size == 0) return false;
        return _expand(p_block,p_size) != NULL;
#else
        return false;
#endif
    }

template<typename t_object >

rcptr_t<t_object> pfc::rcnew_t

(

)

Definition at line 215 of file rcptr.h.

                                {
        rcptr_t<t_object> temp;
        temp.new_t();
        return temp;        
    }

template<typename t_object , typename t_param1 >

rcptr_t<t_object> pfc::rcnew_t

(

t_param1 const &

p_param1

)

Definition at line 222 of file rcptr.h.

                                                         {
        rcptr_t<t_object> temp;
        temp.new_t(p_param1);
        return temp;        
    }

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
	)

Definition at line 229 of file rcptr.h.

                                                                                   {
        rcptr_t<t_object> temp;
        temp.new_t(p_param1,p_param2);
        return temp;        
    }

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
	)

Definition at line 236 of file rcptr.h.

                                                                                                             {
        rcptr_t<t_object> temp;
        temp.new_t(p_param1,p_param2,p_param3);
        return temp;        
    }

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
	)

Definition at line 243 of file rcptr.h.

                                                                                                                                       {
        rcptr_t<t_object> temp;
        temp.new_t(p_param1,p_param2,p_param3,p_param4);
        return temp;        
    }

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
	)

Definition at line 250 of file rcptr.h.

                                                                                                                                                                 {
        rcptr_t<t_object> temp;
        temp.new_t(p_param1,p_param2,p_param3,p_param4,p_param5);
        return temp;
    }

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
	)

Definition at line 257 of file rcptr.h.

                                                                                                                                                                                           {
        rcptr_t<t_object> temp;
        temp.new_t(p_param1,p_param2,p_param3,p_param4,p_param5,p_param6);
        return temp;
    }

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

Definition at line 719 of file primitives.h.

    {
        t_size n,count = p_array.get_size(), total = 0;

        n = total = p_mask.find(true,0,count);

        if (n<count)
        {
            for(n=p_mask.find(false,n+1,count-n-1);n<count;n=p_mask.find(false,n+1,count-n-1))
                move_t(p_array[total++],p_array[n]);

            p_array.set_size(total);
            
            return total;
        }
        else return count;
    }

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

Definition at line 25 of file sort.cpp.

{
    t_size done_size = bit_array_bittable::g_estimate_size(p_count);
    pfc::array_hybrid_t<unsigned char,1024> done;
    done.set_size(done_size);
    pfc::memset_t(done,(unsigned char)0);
    t_size n;
    for(n=0;n<p_count;n++)
    {
        t_size next = p_order[n];
        if (next!=n && !bit_array_bittable::g_get(done,n))
        {
            t_size prev = n;
            do
            {
                PFC_ASSERT(!bit_array_bittable::g_get(done,next));
                PFC_ASSERT(next>n);
                PFC_ASSERT(n<p_count);
                p_callback.swap(prev,next);
                bit_array_bittable::g_set(done,next,true);
                prev = next;
                next = p_order[next];
            } while(next!=n);
            //bit_array_bittable::g_set(done,n,true);
        }
    }
}

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
	)

Definition at line 49 of file sort.h.

    {
        reorder_callback_impl_t<t_container> cb1(p_data);
        reorder_callback_impl_delta cb2( cb1, p_base );
        reorder(cb2,p_order,p_count);
//      reorder(reorder_callback_impl_delta(reorder_callback_impl_t<t_container>(p_data),p_base),p_order,p_count);
    }

template<typename T >

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

Definition at line 72 of file sort.h.

    {
        reorder(reorder_callback_impl_ptr_t<T>(p_data),p_order,p_count);
    }

template<typename t_container >

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

Definition at line 42 of file sort.h.

    {
        reorder_callback_impl_t<t_container> cb(p_data);
        reorder(cb,p_order,p_count);
    }

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
	)

Definition at line 53 of file sort.cpp.

{
    unsigned char * base = (unsigned char *) data;
    t_size done_size = bit_array_bittable::g_estimate_size(num);
    pfc::array_hybrid_t<unsigned char,1024> done;
    done.set_size(done_size);
    pfc::memset_t(done,(unsigned char)0);
    t_size n;
    for(n=0;n<num;n++)
    {
        t_size next = order[n];
        if (next!=n && !bit_array_bittable::g_get(done,n))
        {
            t_size prev = n;
            do
            {
                PFC_ASSERT(!bit_array_bittable::g_get(done,next));
                PFC_ASSERT(next>n);
                PFC_ASSERT(n<num);
                swapfunc(base+width*prev,base+width*next,width);
                bit_array_bittable::g_set(done,next,true);
                prev = next;
                next = order[next];
            } while(next!=n);
            //bit_array_bittable::g_set(done,n,true);
        }
    }
}

template<typename t_type >

t_type pfc::replace_null_t

(

t_type &

p_var

)

Definition at line 688 of file primitives.h.

                                          {
        t_type ret = p_var;
        p_var = 0;
        return ret;
    }

template<typename t_type , typename t_newval >

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

Definition at line 682 of file primitives.h.

                                                               {
        t_type oldval = p_var;
        p_var = p_newval;
        return oldval;
    }

template<unsigned width>

void pfc::reverse_bytes ( t_uint8 *  p_buffer )

inline

Definition at line 231 of file byte_order_helper.h.

                                                  {
        pfc::swap_t(p_buffer[0],p_buffer[width-1]);
        reverse_bytes<width-2>(p_buffer+1);
    }

template<>

void pfc::reverse_bytes< 0 > ( t_uint8 *  p_buffer )

inline

Definition at line 237 of file byte_order_helper.h.

{ }

template<>

void pfc::reverse_bytes< 1 > ( t_uint8 *  p_buffer )

inline

Definition at line 236 of file byte_order_helper.h.

{ }

t_int32 pfc::rint32 ( double  p_val )

inline

Definition at line 712 of file primitives.h.

{return (t_int32) floor(p_val + 0.5);}

t_int64 pfc::rint64 ( double  p_val )

inline

Definition at line 713 of file primitives.h.

{return (t_int64) floor(p_val + 0.5);}

template<typename t_ret , typename t_param >

t_ret* pfc::safe_ptr_cast

(

t_param *

p_param

)

Definition at line 185 of file primitives.h.

                                             {
        if (pfc::is_same_type<t_ret,t_param>::value) return p_param;
        else {
            if (p_param == NULL) return NULL;
            else return p_param;
        }
    }

template<typename t_exception , typename t_int >

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

inline

Definition at line 52 of file alloc.h.

                                                                   {
        t_int newval = p_val << p_shift;
        if (newval >> p_shift != p_val) throw t_exception();
        return newval;
    }

static uint64_t pfc::safeMulAdd ( uint64_t  prev, unsigned  scale, uint64_t  add  )

static

Definition at line 826 of file string_base.cpp.

                                                                        {
    if (add >= scale || scale == 0) throw pfc::exception_invalid_params();
    uint64_t v = prev * scale + add;
    if (v / scale != prev) throw pfc::exception_invalid_params();
    return v;
}

t_size pfc::scan_filename

(

const char *

ptr

)

Definition at line 693 of file string_base.cpp.

{
    t_size n;
    t_size _used = strlen(ptr);
    for(n=_used-1;n!=~0;n--)
    {
        if (is_path_separator(ptr[n])) return n+1;
    }
    return 0;
}

void pfc::selftest

(

)

Definition at line 14 of file selftest.cpp.

{
    PFC_STATIC_ASSERT( sizeof(t_uint8) == 1 );
    PFC_STATIC_ASSERT( sizeof(t_uint16) == 2 );
    PFC_STATIC_ASSERT( sizeof(t_uint32) == 4 );
    PFC_STATIC_ASSERT( sizeof(t_uint64) == 8 );

    PFC_STATIC_ASSERT( sizeof(t_int8) == 1 );
    PFC_STATIC_ASSERT( sizeof(t_int16) == 2 );
    PFC_STATIC_ASSERT( sizeof(t_int32) == 4 );
    PFC_STATIC_ASSERT( sizeof(t_int64) == 8 );

    PFC_STATIC_ASSERT( sizeof(t_float32) == 4 );
    PFC_STATIC_ASSERT( sizeof(t_float64) == 8 );

    PFC_STATIC_ASSERT( sizeof(t_size) == sizeof(void*) );
    PFC_STATIC_ASSERT( sizeof(t_ssize) == sizeof(void*) );

    PFC_STATIC_ASSERT( sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4 );

    PFC_STATIC_ASSERT( sizeof(GUID) == 16 );

    typedef pfc::avltree_t<int> t_asdf;
    t_asdf asdf; asdf.add_item(1);
    t_asdf::iterator iter = asdf._first_var();
    t_asdf::const_iterator iter2 = asdf._first_var();
    
    PFC_string_formatter() << "foo" << 1337 << foo();
    
    pfc::list_t<int> l; l.add_item(3);

}

void pfc::setCloseOnExec	(	int	fd,
		bool	bCloseOnExec
	)

Definition at line 27 of file nix-objects.cpp.

                                                     {
        int flags = fcntl(fd, F_GETFD);
        int flags2 = flags;
        if (bCloseOnExec) flags2 |= FD_CLOEXEC;
        else flags2 &= ~FD_CLOEXEC;
        if (flags != flags2) fcntl(fd, F_SETFD, flags2);
    }

void pfc::setInheritable	(	int	fd,
		bool	bInheritable
	)

Definition at line 35 of file nix-objects.cpp.

                                                     {
        setCloseOnExec( fd, !bInheritable );
    }

void pfc::setNonBlocking	(	int	fd,
		bool	bNonBlocking
	)

Definition at line 19 of file nix-objects.cpp.

                                                     {
        int flags = fcntl(fd, F_GETFL, 0);
        int flags2 = flags;
        if (bNonBlocking) flags2 |= O_NONBLOCK;
        else flags2 &= ~O_NONBLOCK;
        if (flags2 != flags) fcntl(fd, F_SETFL, flags2);
    }

template<typename T >

int pfc::sgn_t

(

const T &

p_val

)

Definition at line 669 of file primitives.h.

                               {
        if (p_val < 0) return -1;
        else if (p_val > 0) return 1;
        else return 0;
    }

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

Definition at line 252 of file utf8.cpp.

{
    t_size num = 0;
    for(;count && ptr[num];count--)
    {
        t_size d = utf8_char_len(ptr+num);
        if (d<=0) break;
        num+=d;     
    }
    return num;
}

void pfc::sort	(	pfc::sort_callback &	p_callback,
		t_size	p_num
	)

Definition at line 225 of file sort.cpp.

                                                      {
    srand((unsigned int)(uniqueVal() ^ p_num));
    newsort(p_callback,0,p_num);
}

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  )

static

Definition at line 176 of file sort.h.

    {
        sort_callback_impl_permutation_wrap_t<t_container,t_compare,t_permutation> cb(p_data,p_compare,p_permutation);
        sort(cb,p_count);
    }

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

Definition at line 261 of file sort.cpp.

{
    sort_callback_stabilizer cb(p_callback,p_count);
    sort(cb,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  )

static

Definition at line 183 of file sort.h.

    {
        sort_callback_impl_permutation_wrap_t<t_container,t_compare,t_permutation> cb(p_data,p_compare,p_permutation);
        sort_stable(cb,p_count);
    }

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  )

static

Definition at line 169 of file sort.h.

    {
        sort_callback_impl_simple_wrap_t<t_container,t_compare> cb(p_data,p_compare);
        sort_stable(cb,p_count);
    }

template<typename t_container , typename t_compare >

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

static

Definition at line 162 of file sort.h.

    {
        sort_callback_impl_simple_wrap_t<t_container,t_compare> cb(p_data,p_compare);
        sort(cb,p_count);
    }

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

Definition at line 231 of file sort.cpp.

{
    sort_void_ex(base,num,width,comp,swap_void);
}

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
	)

Definition at line 116 of file sort.cpp.

{
    sort_callback_impl_legacy cb(base,width,comp,swap);
    sort(cb,num);
}

template<typename t_out >

void pfc::splitStringByChar	(	t_out &	out,
		const char *	str,
		char	c
	)

Definition at line 987 of file string_base.h.

                                                                                           {
        for(;;) {
            const char * next = strchr(str, c);
            if (next == NULL) {
                out += string_part(str, strlen(str)); break;
            }
            out += string_part(str, next - str);
            str = next + 1;
        }
    }

template<typename t_out >

void pfc::splitStringByLines	(	t_out &	out,
		const char *	str
	)

Definition at line 975 of file string_base.h.

                                                                                    {
        for(;;) {
            const char * next = strchr(str, '\n');
            if (next == NULL) {
                out += string_part(str, strlen(str)); break;
            }
            const char * walk = next;
            while(walk > str && walk[-1] == '\r') --walk;
            out += string_part(str, walk - str);
            str = next + 1;
        }
    }

template<typename t_out >

void pfc::splitStringBySubstring	(	t_out &	out,
		const char *	str,
		const char *	split
	)

Definition at line 997 of file string_base.h.

                                                                                                            {
        for(;;) {
            const char * next = strstr(str, split);
            if (next == NULL) {
                out += string_part(str, strlen(str)); break;
            }
            out += string_part(str, next - str);
            str = next + strlen(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
	)

Definition at line 870 of file string_base.h.

                                                                                                                          {
        t_size walk = 0, splitBase = 0;
        const t_size max = strlen_max(p_string,p_stringLen);
        for(;walk < max;) {
            t_size delta = p_check(p_string + walk,max - walk);
            if (delta > 0) {
                if (walk > splitBase) p_output(p_string + splitBase, walk - splitBase);
                splitBase = walk + delta;
            } else {
                delta = utf8_char_len(p_string + walk, max - walk);
                if (delta == 0) break;
            }
            walk += delta;
        }
        if (walk > splitBase) p_output(p_string + splitBase, walk - splitBase);
    }

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
	)

Definition at line 953 of file string_base.h.

                                                                                                                        {
        _splitStringSimple_check<t_split> strCheck(p_split);

        {
            __splitStringSimple_calculateSubstringCount wrapper;
            splitStringEx(wrapper,strCheck,p_string,p_stringLen);
            p_output.set_size(wrapper.get());
        }

        {
            __splitStringSimple_arrayWrapper<t_array> wrapper(p_output);
            splitStringEx(wrapper,strCheck,p_string,p_stringLen);
        }
    }

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
	)

Definition at line 968 of file string_base.h.

                                                                                                                      {
        _splitStringSimple_check<t_split> strCheck(p_split);

        __splitStringSimple_listWrapper<t_list> wrapper(p_output);
        splitStringEx(wrapper,strCheck,p_string,p_stringLen);
    }

template<typename T >

T pfc::sqr_t ( T  item )

inline

Definition at line 562 of file primitives.h.

{return item * item;}

static void pfc::squaresort ( pfc::sort_callback &  p_callback, t_size const  p_base, t_size const  p_count  )

static

Definition at line 127 of file sort.cpp.

                                                                                               {
    const t_size max = p_base + p_count;
    for(t_size walk = p_base + 1; walk < max; ++walk) {
        for(t_size prev = p_base; prev < walk; ++prev) {
            p_callback.swap_check(prev,walk);
        }
    }
}

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

Definition at line 332 of file string_base.cpp.

{
    n1 = strlen_max(p1,n1); n2 = strlen_max(p2,n2);
    return strcmp_nc(p1, n1, p2, n2);
}

int pfc::strcmp_nc	(	const char *	p1,
		size_t	n1,
		const char *	p2,
		size_t	n2
	)
throw	(
	)

Definition at line 316 of file string_base.cpp.

                                                                             {
    t_size idx = 0;
    for(;;)
    {
        if (idx == n1 && idx == n2) return 0;
        else if (idx == n1) return -1;//end of param1
        else if (idx == n2) return 1;//end of param2

        char c1 = p1[idx], c2 = p2[idx];
        if (c1<c2) return -1;
        else if (c1>c2) return 1;
        
        idx++;
    }
}

int pfc::strcmp_partial ( const char *  str, const char *  substr  ) throw ( )

inline

Definition at line 1088 of file string_base.h.

{return strcmp_partial_t(str, substr); }

int pfc::strcmp_partial_ex ( const char *  str, t_size  strLen, const char *  substr, t_size  substrLen  ) throw ( )

inline

Definition at line 1087 of file string_base.h.

{return strcmp_partial_ex(str, strLen, substr, substrLen); }

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	(
	)

Definition at line 1079 of file string_base.h.

                                                                                                                                                                   {
        p_string_length = strlen_max_t(p_string,p_string_length); p_substring_length = strlen_max_t(p_substring,p_substring_length);
        return _strcmp_partial_ex(p_string,p_string_length,p_substring,p_substring_length);
    }

template<typename t_char >

int pfc::strcmp_partial_t	(	const t_char *	p_string,
		const t_char *	p_substring
	)
throw	(
	)

Definition at line 1085 of file string_base.h.

{return strcmp_partial_ex_t(p_string,~0,p_substring,~0);}

template<typename char_t >

void pfc::strcpy_t	(	char_t *	out,
		const char_t *	in
	)

Definition at line 141 of file string_base.h.

                                                                               {
        for(;;) { char_t c = *in++; *out++ = c; if (c == 0) break; }
    }

t_size pfc::strcpy_utf8_truncate	(	const char *	src,
		char *	out,
		t_size	maxbytes
	)

unsigned pfc::strcpy_utf8_truncate	(	const char *	src,
		char *	out,
		unsigned	maxbytes
	)

Definition at line 295 of file utf8.cpp.

{
    unsigned rv = 0 , ptr = 0;
    if (maxbytes>0)
    {   
        maxbytes--;//for null
        while(!check_end_of_string(src) && maxbytes>0)
        {
            t_size delta = utf8_char_len(src);
            if (delta>maxbytes || delta==0) break;
            do 
            {
                out[ptr++] = *(src++);
            } while(--delta);
            rv = ptr;
        }
        out[rv]=0;
    }
    return rv;
}

char * pfc::strdup_n	(	const char *	src,
		t_size	len
	)

Definition at line 75 of file string_base.cpp.

{
    len = strlen_max(src,len);
    char * ret = (char*)malloc(len+1);
    if (ret)
    {
        memcpy(ret,src,len);
        ret[len]=0;
    }
    return ret;
}

int pfc::stricmp_ascii	(	const char *	s1,
		const char *	s2
	)
throw	(
	)

Definition at line 419 of file string_base.cpp.

                                                           {
    for(;;) {
        char c1 = *s1, c2 = *s2;

        if (c1 > 0 && c2 > 0) {
            c1 = ascii_tolower_lookup(c1);
            c2 = ascii_tolower_lookup(c2);
        } else {
            if (c1 == 0 && c2 == 0) return 0;
        }
        if (c1<c2) return -1;
        else if (c1>c2) return 1;
        else if (c1 == 0) return 0;

        s1++;
        s2++;
    }
}

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

Definition at line 405 of file string_base.cpp.

                                                                                                              {
    t_size walk1 = 0, walk2 = 0;
    for(;;) {
        char c1 = (walk1 < len1) ? s1[walk1] : 0;
        char c2 = (walk2 < len2) ? s2[walk2] : 0;
        c1 = ascii_tolower(c1); c2 = ascii_tolower(c2);
        if (c1<c2) return -1;
        else if (c1>c2) return 1;
        else if (c1 == 0) return 0;
        walk1++;
        walk2++;
    }

}

int pfc::stricmp_ascii_partial	(	const char *	str,
		const char *	substr
	)
throw	(
	)

Definition at line 391 of file string_base.cpp.

                                                                          {
    size_t walk = 0;
    for(;;) {
        char c1 = str[walk];
        char c2 = substr[walk];
        c1 = ascii_tolower(c1); c2 = ascii_tolower(c2);
        if (c2 == 0) return 0; // substr terminated = ret0 regardless of str content
        if (c1<c2) return -1; // ret -1 early
        else if (c1>c2) return 1; // ret 1 early
        // else c1 == c2 and c2 != 0 so c1 != 0 either
        ++walk; // go on
    }
}

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

Definition at line 706 of file string_base.cpp.

                                                                             {
    for(t_size walk = p_start; p_string[walk]; ++walk) {
        if (p_string[walk] == p_tofind) return walk;
    }
    return ~0;
}

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

Definition at line 715 of file string_base.cpp.

                                                                                     {
    return string_find_first_ex(p_string,~0,p_tofind,~0,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
	)

Definition at line 722 of file string_base.cpp.

                                                                                                       {
    for(t_size walk = p_start; walk < p_string_length && p_string[walk]; ++walk) {
        if (p_string[walk] == p_tofind) return walk;
    }
    return ~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
	)

Definition at line 731 of file string_base.cpp.

                                                                                                                                      {
    p_string_length = strlen_max(p_string,p_string_length); p_tofind_length = strlen_max(p_tofind,p_tofind_length);
    if (p_string_length >= p_tofind_length) {
        t_size max = p_string_length - p_tofind_length;
        for(t_size walk = p_start; walk <= max; walk++) {
            if (_strcmp_partial_ex(p_string+walk,p_string_length-walk,p_tofind,p_tofind_length) == 0) return walk;
        }
    }
    return ~0;
}

t_size pfc::string_find_first_nc	(	const char *	p_string,
		t_size	p_string_length,
		char	c,
		t_size	p_start
	)

Definition at line 752 of file string_base.cpp.

                                                                                                {
    for(t_size walk = p_start; walk < p_string_length; walk++) {
        if (p_string[walk] == c) return walk;
    }
    return ~0;
}

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
	)

Definition at line 759 of file string_base.cpp.

                                                                                                                                      {
    if (p_string_length >= p_tofind_length) {
        t_size max = p_string_length - p_tofind_length;
        for(t_size walk = p_start; walk <= max; walk++) {
            if (memcmp(p_string+walk, p_tofind, p_tofind_length) == 0) return walk;
        }
    }
    return ~0;
}

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

Definition at line 712 of file string_base.cpp.

                                                                            {
    return string_find_last_ex(p_string,~0,&p_tofind,1,p_start);
}

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

Definition at line 718 of file string_base.cpp.

                                                                                    {
    return string_find_last_ex(p_string,~0,p_tofind,~0,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
	)

Definition at line 728 of file string_base.cpp.

                                                                                                      {
    return string_find_last_ex(p_string,p_string_length,&p_tofind,1,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
	)

Definition at line 741 of file string_base.cpp.

                                                                                                                                     {
    p_string_length = strlen_max(p_string,p_string_length); p_tofind_length = strlen_max(p_tofind,p_tofind_length);
    if (p_string_length >= p_tofind_length) {
        t_size max = min_t<t_size>(p_string_length - p_tofind_length,p_start);
        for(t_size walk = max; walk != (t_size)(-1); walk--) {
            if (_strcmp_partial_ex(p_string+walk,p_string_length-walk,p_tofind,p_tofind_length) == 0) return walk;
        }
    }
    return ~0;
}

bool pfc::string_has_prefix	(	const char *	string,
		const char *	prefix
	)

Definition at line 1176 of file string_base.cpp.

                                                                       {
        for(size_t w = 0; ; ++w ) {
            char c = prefix[w];
            if (c == 0) return true;
            if (string[w] != c) return false;
        }
    }

bool pfc::string_has_prefix_i	(	const char *	string,
		const char *	prefix
	)

Definition at line 1183 of file string_base.cpp.

                                                                         {
        const char * p1 = string; const char * p2 = prefix;
        for(;;) {
            unsigned w1, w2; size_t d1, d2;
            d1 = utf8_decode_char(p1, w1);
            d2 = utf8_decode_char(p2, w2);
            if (d2 == 0) return true;
            if (d1 == 0) return false;
            if (w1 != w2) {
                if (charLower(w1) != charLower(w2)) return false;
            }
            p1 += d1; p2 += d2;
        }
    }

bool pfc::string_has_suffix	(	const char *	string,
		const char *	suffix
	)

Definition at line 1197 of file string_base.cpp.

                                                                       {
        size_t len = strlen( string );
        size_t suffixLen = strlen( suffix );
        if (suffixLen > len) return false;
        size_t base = len - suffixLen;
        return memcmp( string + base, suffix, suffixLen * sizeof(char)) == 0;
    }

bool pfc::string_has_suffix_i	(	const char *	string,
		const char *	suffix
	)

Definition at line 1204 of file string_base.cpp.

                                                                         {
        for(;;) {
            if (*string == 0) return false;
            if (stringEqualsI_utf8( string, suffix )) return true;
            if (!utf8_advance(string)) return false;
        }
    }

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

Definition at line 770 of file string_base.cpp.

                                                                      {
    bool retval = false;
    for(t_size walk = 0; walk < p_length && p_string[walk] != 0; walk++) {
        if (!char_is_numeric(p_string[walk])) {retval = false; break;}
        retval = true;
    }
    return retval;
}

string_part_ref pfc::string_part ( const char *  ptr, t_size  len  )

inline

Definition at line 31 of file string_base.h.

                                                                     {
        string_part_ref val = {ptr, len}; return val;
    }

double pfc::string_to_float	(	const char *	src,
		t_size	max
	)

Definition at line 245 of file string_base.cpp.

                                                    {
    //old function wants an oldstyle nullterminated string, and i don't currently care enough to rewrite it as it works appropriately otherwise
    char blargh[128];
    if (max > 127) max = 127;
    t_size walk;
    for(walk = 0; walk < max && src[walk]; walk++) blargh[walk] = src[walk];
    blargh[walk] = 0;
    return pfc_string_to_float_internal(blargh);
}

template<typename t_source >

static void pfc::stringCombine ( pfc::string_base &  out, t_source const &  in, const char *  separator, const char *  separatorLast  )

static

Definition at line 858 of file string_base.h.

                                                                                                                                                         {
        out.reset();
        for(typename t_source::const_iterator walk = in.first(); walk.is_valid(); ++walk) {
            if (!out.is_empty()) {
                if (walk == in.last()) out << separatorLast;
                else out << separator;
            }
            out << stringToPtr(*walk);
        }
    }

template<typename TList >

string pfc::stringCombineList	(	const TList &	list,
		stringp	separator
	)

Definition at line 243 of file stringNew.h.

                                                                    {
        typename TList::const_iterator iter = list.first();
        string acc;
        if (iter.is_valid()) {
            acc = *iter;
            for(++iter; iter.is_valid(); ++iter) {
                acc = acc + separator + *iter;
            }
        }
        return acc;
    }

int pfc::stringCompareCaseInsensitive	(	const char *	s1,
		const char *	s2
	)

Definition at line 930 of file string_base.cpp.

                                                                   {
    for(;;) {
        unsigned c1, c2; t_size d1, d2;
        d1 = utf8_decode_char(s1,c1);
        d2 = utf8_decode_char(s2,c2);
        if (d1 == 0 && d2 == 0) return 0;
        else if (d1 == 0) return -1;
        else if (d2 == 0) return 1;
        else {
            c1 = charLower(c1); c2 = charLower(c2);
            if (c1 < c2) return -1;
            else if (c1 > c2) return 1;
        }
        s1 += d1; s2 += d2;
    }
}

int pfc::stringCompareCaseInsensitiveEx	(	string_part_ref	s1,
		string_part_ref	s2
	)

Definition at line 913 of file string_base.cpp.

                                                                           {
    t_size w1 = 0, w2 = 0;
    for(;;) {
        unsigned c1, c2; t_size d1, d2;
        d1 = utf8_decode_char(s1.m_ptr + w1, c1, s1.m_len - w1);
        d2 = utf8_decode_char(s2.m_ptr + w2, c2, s2.m_len - w2);
        if (d1 == 0 && d2 == 0) return 0;
        else if (d1 == 0) return -1;
        else if (d2 == 0) return 1;
        else {
            c1 = charLower(c1); c2 = charLower(c2);
            if (c1 < c2) return -1;
            else if (c1 > c2) return 1;
        }
        w1 += d1; w2 += d2;
    }
}

bool pfc::stringEqualsI_ascii	(	const char *	p1,
		const char *	p2
	)
throw	(
	)

Definition at line 1121 of file string_base.cpp.

                                                                  {
    for(;;)
    {
        char c1 = *p1;
        char c2 = *p2;
        if (c1 > 0 && c2 > 0) {
            if (ascii_tolower_table[c1] != ascii_tolower_table[c2]) return false;
        } else {
            if (c1 == 0 && c2 == 0) return true;
            if (c1 == 0 || c2 == 0) return false;
            if (c1 != c2) return false;
        }
        ++p1; ++p2;
    }
}

bool pfc::stringEqualsI_utf8	(	const char *	p1,
		const char *	p2
	)
throw	(
	)

Definition at line 1137 of file string_base.cpp.

{
    for(;;)
    {
        char c1 = *p1;
        char c2 = *p2;
        if (c1 > 0 && c2 > 0) {
            if (ascii_tolower_table[c1] != ascii_tolower_table[c2]) return false;
            ++p1; ++p2;
        } else {
            if (c1 == 0 && c2 == 0) return true;
            if (c1 == 0 || c2 == 0) return false;
            unsigned w1,w2; t_size d1,d2;
            d1 = utf8_decode_char(p1,w1);
            d2 = utf8_decode_char(p2,w2);
            if (d1 == 0 || d2 == 0) return false; // bad UTF-8, bail
            if (w1 != w2) {
                if (charLower(w1) != charLower(w2)) return false;
            }
            p1 += d1;
            p2 += d2;
        }
    }
}

template<typename TChar , t_size len, typename TSource >

void pfc::stringToBuffer	(	TChar(&)	buffer[len],
		const TSource &	source
	)

Writes a string to a fixed-size buffer. Truncates the string if necessary. Always writes a null terminator.

Definition at line 1047 of file string_base.h.

                                                                      {
        PFC_STATIC_ASSERT(len>0);
        t_size walk;
        for(walk = 0; walk < len - 1 && source[walk] != 0; ++walk) {
            buffer[walk] = source[walk];
        }
        buffer[walk] = 0;
    }

template<typename TChar , t_size len, typename TSource >

void pfc::stringToBufferGuarded	(	TChar(&)	buffer[len],
		const TSource &	source
	)

Same as stringToBuffer() but throws exception_overflow() if the string could not be fully written, including null terminator.

Definition at line 1058 of file string_base.h.

                                                                             {
        t_size walk;
        for(walk = 0; source[walk] != 0; ++walk) {
            if (walk >= len) throw exception_overflow();
            buffer[walk] = source[walk];
        }
        if (walk >= len) throw exception_overflow();
        buffer[walk] = 0;
    }

void pfc::stringToLowerAppend	(	string_base &	out,
		const char *	src,
		t_size	len
	)

Definition at line 903 of file string_base.cpp.

                                                                          {
    while(len && *src) {
        unsigned c; t_size d;
        d = utf8_decode_char(src,c,len);
        if (d==0 || d>len) break;
        out.add_char(charLower(c));
        src+=d;
        len-=d;
    }
}

template<typename T >

const char* pfc::stringToPtr ( T const &  val )

inline

Definition at line 1018 of file string_base.h.

{return val.get_ptr();}

template<>

const char* pfc::stringToPtr ( std::string const &  val )

inline

Definition at line 1019 of file string_base.h.

{return val.c_str();}

const char* pfc::stringToPtr ( const char *  val )

inline

Definition at line 1020 of file string_base.h.

{return val;}

template<typename T >

static string_part_ref pfc::stringToRef ( T const &  val )

static

Definition at line 1022 of file string_base.h.

{return string_part(stringToPtr(val), val.length());}

string_part_ref pfc::stringToRef ( string_part_ref  val )

inline

Definition at line 1023 of file string_base.h.

{return val;}

string_part_ref pfc::stringToRef ( const char *  val )

inline

Definition at line 1024 of file string_base.h.

{return string_part(val, strlen(val));}

void pfc::stringToUpperAppend	(	string_base &	out,
		const char *	src,
		t_size	len
	)

Definition at line 893 of file string_base.cpp.

                                                                          {
    while(len && *src) {
        unsigned c; t_size d;
        d = utf8_decode_char(src,c,len);
        if (d==0 || d>len) break;
        out.add_char(charUpper(c));
        src+=d;
        len-=d;
    }
}

t_size pfc::strlen_max ( const char *  ptr, t_size  max  ) throw ( )

inline

Definition at line 91 of file string_base.h.

{return strlen_max_t(ptr,max);}

template<typename t_char >

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

Definition at line 84 of file string_base.h.

                                                       {
        PFC_ASSERT( ptr != NULL || max == 0 );
        t_size n = 0;
        while(n<max && ptr[n] != 0) n++;
        return n;
    }

template<typename t_char >

t_size pfc::strlen_t	(	const t_char *	p_string,
		t_size	p_length = ~0
	)

Definition at line 771 of file primitives.h.

                                                                  {
        for(t_size walk = 0;;walk++) {
            if (walk >= p_length || p_string[walk] == 0) return walk;
        }
    }

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

Definition at line 316 of file utf8.cpp.

{
    unsigned w;
    t_size d;
    t_size ret = 0;
    for(;num;)
    {
        d = utf8_decode_char(p,w);
        if (w==0 || d<=0) break;
        ret++;
        p+=d;
        num-=d;
    }
    return ret;
}

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

Definition at line 288 of file string_base.cpp.

{
    p_string_len = strlen_max(p_string,p_string_len);
    p_substring_len = strlen_max(p_substring,p_substring_len);
    t_size index = 0;
    while(index + p_substring_len <= p_string_len)
    {
        if (memcmp(p_string+index,p_substring,p_substring_len) == 0) return index;
        t_size delta = utf8_char_len(p_string+index,p_string_len - index);
        if (delta == 0) break;
        index += delta;
    }
    return ~0;
}

template<typename t_int >

t_int pfc::sub_unsigned_clipped	(	t_int	v1,
		t_int	v2
	)

Definition at line 601 of file primitives.h.

                                                                            {
        t_int v = v1 - v2;
        if (v > v1) return 0;
        return v;
    }

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
	)

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).

Definition at line 395 of file primitives.h.

                                                                                                                       {
        p_destination.set_size(subtract_sorted_lists_calculate_count(p_source1,p_source2));
        t_size walk1 = 0, walk2 = 0, walk_out = 0;
        const t_size max1 = p_source1.get_size(), max2 = p_source2.get_size();
        for(;;) {
            int state;
            if (walk1 < max1 && walk2 < max2) {
                state = pfc::compare_t(p_source1[walk1],p_source2[walk2]);
            } else if (walk1 < max1) {
                state = -1;
            } else if (walk2 < max2) {
                state = 1;
            } else {
                break;
            }
            
            
            if (state < 0) p_destination[walk_out++] = p_source1[walk1];
            if (state <= 0) walk1++;
            if (state >= 0) walk2++;
        }
    }

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
	)

Definition at line 371 of file primitives.h.

                                                                                                           {
        t_size walk1 = 0, walk2 = 0, walk_out = 0;
        const t_size max1 = p_source1.get_size(), max2 = p_source2.get_size();
        for(;;) {
            int state;
            if (walk1 < max1 && walk2 < max2) {
                state = pfc::compare_t(p_source1[walk1],p_source2[walk2]);
            } else if (walk1 < max1) {
                state = -1;
            } else if (walk2 < max2) {
                state = 1;
            } else {
                break;
            }
            if (state < 0) walk_out++;
            if (state <= 0) walk1++;
            if (state >= 0) walk2++;
        }
        return walk_out;
    }

template<typename T >

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

inline

Definition at line 253 of file primitives.h.

                                                                        {
        T * walk1 = p_buffer1, * walk2 = p_buffer2;
        for(t_size n=p_size;n;--n) {
            T temp (* walk1);
            *walk1 = *walk2;
            *walk2 = temp;
            walk1++; walk2++;
        }
    }

template<typename T , t_size p_size>

void pfc::swap_multi_t ( T *  p_buffer1, T *  p_buffer2  )

inline

Definition at line 264 of file primitives.h.

                                                          {
        T * walk1 = p_buffer1, * walk2 = p_buffer2;
        for(t_size n=p_size;n;--n) {
            T temp (* walk1);
            *walk1 = *walk2;
            *walk2 = temp;
            walk1++; walk2++;
        }
    }

template<typename T >

void pfc::swap_t ( T &  p_item1, T &  p_item2  )

inline

Definition at line 285 of file primitives.h.

                                                 {
        if (traits_t<T>::realloc_safe) {
            __unsafe__swap_raw_t<sizeof(T)>( reinterpret_cast<void*>( &p_item1 ), reinterpret_cast<void*>( &p_item2 ) );
        } else {
            T temp( std::move(p_item2) );
            p_item2 = std::move(p_item1);
            p_item1 = std::move(temp);
        }
    }

template<>

void pfc::swap_t ( string8 &  p_item1, string8 &  p_item2  )

inline

Definition at line 544 of file string_base.h.

    {
        string8::g_swap(p_item1,p_item2);
    }

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

Definition at line 10 of file sort.cpp.

{
    unsigned char * ptr1 = (unsigned char*)item1, * ptr2 = (unsigned char*)item2;
    t_size n;
    unsigned char temp;
    for(n=0;n<width;n++)
    {
        temp = *ptr2;
        *ptr2 = *ptr1;
        *ptr1 = temp;
        ptr1++;
        ptr2++;
    }
}

t_size pfc::tcslen_max ( const TCHAR *  ptr, t_size  max  )

inline

Definition at line 95 of file string_base.h.

{return strlen_max_t(ptr,max);}

template<typename t_exception >

PFC_NORETURN void pfc::throw_exception_with_message ( const char *  p_message )

inline

Definition at line 37 of file primitives.h.

                                                                                                                 {
        throw t_exception(p_message);
    }

template<typename T >

string pfc::toString ( T const &  val )

inline

Definition at line 203 of file stringNew.h.

{return val.toString();}

template<>

string pfc::toString ( t_int64 const &  val )

inline

Definition at line 204 of file stringNew.h.

{return format_int(val).get_ptr();}

template<>

string pfc::toString ( t_int32 const &  val )

inline

Definition at line 205 of file stringNew.h.

{return format_int(val).get_ptr();}

template<>

string pfc::toString ( t_int16 const &  val )

inline

Definition at line 206 of file stringNew.h.

{return format_int(val).get_ptr();}

template<>

string pfc::toString ( t_uint64 const &  val )

inline

Definition at line 207 of file stringNew.h.

{return format_uint(val).get_ptr();}

template<>

string pfc::toString ( t_uint32 const &  val )

inline

Definition at line 208 of file stringNew.h.

{return format_uint(val).get_ptr();}

template<>

string pfc::toString ( t_uint16 const &  val )

inline

Definition at line 209 of file stringNew.h.

{return format_uint(val).get_ptr();}

template<>

string pfc::toString ( float const &  val )

inline

Definition at line 210 of file stringNew.h.

{return format_float(val).get_ptr();}

template<>

string pfc::toString ( double const &  val )

inline

Definition at line 211 of file stringNew.h.

{return format_float(val).get_ptr();}

template<>

string pfc::toString ( char const &  val )

inline

Definition at line 212 of file stringNew.h.

{return string(&val,1);}

const char* pfc::toString ( std::exception const &  val )

inline

Definition at line 213 of file stringNew.h.

{return val.what();}

static counter::t_val pfc::uniqueVal ( )

inlinestatic

Definition at line 143 of file sort.cpp.

{return __rdtsc();}

void pfc::urlEncode	(	pfc::string_base &	out,
		const char *	in
	)

Definition at line 1074 of file string_base.cpp.

                                                      {
    out.reset(); urlEncodeAppend(out, in);
}

void pfc::urlEncodeAppend	(	pfc::string_base &	out,
		const char *	in
	)

Definition at line 1065 of file string_base.cpp.

                                                            {
    for(;;) {
        const char c = *(in++);
        if (c == 0) break;
        else if (c == ' ') out.add_byte('+');
        else if (pfc::char_is_ascii_alphanumeric(c) || c == '_') out.add_byte(c);
        else out << "%" << pfc::format_hex((t_uint8)c, 2);
    }
}

void pfc::urlEncodeAppendRaw	(	pfc::string_base &	out,
		const char *	in,
		t_size	inSize
	)

Definition at line 1057 of file string_base.cpp.

                                                                              {
    for(t_size walk = 0; walk < inSize; ++walk) {
        const char c = in[walk];
        if (c == ' ') out.add_byte('+');
        else if (pfc::char_is_ascii_alphanumeric(c) || c == '_') out.add_byte(c);
        else out << "%" << pfc::format_hex((t_uint8)c, 2);
    }
}

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

Definition at line 181 of file utf8.cpp.

                                                                                                    {
    if (p_source_length == 0) {*p_out = 0; return 0; }
    else if (p_source_length == 1) {
        *p_out = p_source[0];
        return 1;
    } else {
        t_size retval = 0;
        unsigned decoded = p_source[0];
        if (decoded != 0)
        {
            retval = 1;
            if ((decoded & 0xFC00) == 0xD800)
            {
                unsigned low = p_source[1];
                if ((low & 0xFC00) == 0xDC00)
                {
                    decoded = 0x10000 + ( ((decoded & 0x3FF) << 10) | (low & 0x3FF) );
                    retval = 2;
                }
            }
        }
        *p_out = decoded;
        return retval;
    }
}

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

Definition at line 207 of file utf8.cpp.

                                                                                                       {
        PFC_STATIC_ASSERT( sizeof(wchar_t) == sizeof(char16_t) );
        return wide_decode_char( p_source, p_out, p_source_length );
    }

t_size pfc::utf16_encode_char	(	unsigned	c,
		char16_t *	out
	)
throw	(
	)

Definition at line 165 of file utf8.cpp.

{
    if (cur_wchar < 0x10000) {
        *out = (char16_t) cur_wchar; return 1;
    } else if (cur_wchar < (1 << 20)) {
        unsigned c = cur_wchar - 0x10000;
        //MSDN:
        //The first (high) surrogate is a 16-bit code value in the range U+D800 to U+DBFF. The second (low) surrogate is a 16-bit code value in the range U+DC00 to U+DFFF. Using surrogates, Unicode can support over one million characters. For more details about surrogates, refer to The Unicode Standard, version 2.0.
        out[0] = (char16_t)(0xD800 | (0x3FF & (c>>10)) );
        out[1] = (char16_t)(0xDC00 | (0x3FF & c) ) ;
        return 2;
    } else {
        *out = '?'; return 1;
    }
}

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

Definition at line 211 of file utf8.cpp.

                                                               {
        PFC_STATIC_ASSERT( sizeof(wchar_t) == sizeof(char16_t) );
        return wide_encode_char( c, out );
    }

bool pfc::utf8_advance ( const char *&  var ) throw ( )

inline

Definition at line 178 of file string_base.h.

                                                         {
        t_size delta = utf8_char_len(var);
        var += delta;
        return delta>0;
    }

bool pfc::utf8_advance ( char *&  var ) throw ( )

inline

Definition at line 184 of file string_base.h.

                                                   {
        t_size delta = utf8_char_len(var);
        var += delta;
        return delta>0;
    }

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

Definition at line 246 of file utf8.cpp.

{
    unsigned dummy;
    return utf8_decode_char(s,dummy,max);
}

t_size pfc::utf8_char_len_from_header	(	char	c	)
throw	(
	)

Definition at line 10 of file utf8.cpp.

{
    t_size cnt = 0;
    for(;;)
    {
        if ((p_c & mask_tab[cnt])==val_tab[cnt]) break;
        if (++cnt>=6) return 0;
    }

    return cnt + 1;

}

const char* pfc::utf8_char_next ( const char *  src ) throw ( )

inline

Definition at line 190 of file string_base.h.

{return src + utf8_char_len(src);}

char* pfc::utf8_char_next ( char *  src ) throw ( )

inline

Definition at line 191 of file string_base.h.

{return src + utf8_char_len(src);}

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

Definition at line 332 of file utf8.cpp.

{
    t_size bytes = 0;
    while(count)
    {
        unsigned dummy;
        t_size delta = utf8_decode_char(string+bytes,dummy);
        if (delta==0) break;
        bytes += delta;
        count--;
    }
    return bytes;
}

t_size pfc::utf8_decode_char	(	const char *	src,
		unsigned &	out,
		t_size	src_bytes
	)
throw	(
	)

Definition at line 64 of file utf8.cpp.

{
    const t_uint8 * utf8 = (const t_uint8*)p_utf8;
    
    if (max==0) {
        wide = 0;
        return 0;
    }

    if (utf8[0]<0x80) {
        wide = utf8[0];
        return utf8[0]>0 ? 1 : 0;
    }
    if (max>6) max = 6;
    wide = 0;

    unsigned res=0;
    unsigned n;
    unsigned cnt=0;
    for(;;)
    {
        if ((*utf8&mask_tab[cnt])==val_tab[cnt]) break;
        if (++cnt>=max) return 0;
    }
    cnt++;

    if (cnt==2 && !(*utf8&0x1E)) return 0;

    if (cnt==1)
        res=*utf8;
    else
        res=(0xFF>>(cnt+1))&*utf8;

    for (n=1;n<cnt;n++)
    {
        if ((utf8[n]&0xC0) != 0x80)
            return 0;
        if (!res && n==2 && !((utf8[n]&0x7F) >> (7 - cnt)))
            return 0;

        res=(res<<6)|(utf8[n]&0x3F);
    }

    wide = res;

    return cnt;
}

t_size pfc::utf8_decode_char	(	const char *	src,
		unsigned &	out
	)
throw	(
	)

Definition at line 22 of file utf8.cpp.

                                                                    {
    const t_uint8 * utf8 = (const t_uint8*)p_utf8;
    const t_size max = 6;

    if (utf8[0]<0x80) {
        wide = utf8[0];
        return utf8[0]>0 ? 1 : 0;
    }
    wide = 0;

    unsigned res=0;
    unsigned n;
    unsigned cnt=0;
    for(;;)
    {
        if ((*utf8&mask_tab[cnt])==val_tab[cnt]) break;
        if (++cnt>=max) return 0;
    }
    cnt++;

    if (cnt==2 && !(*utf8&0x1E)) return 0;

    if (cnt==1)
        res=*utf8;
    else
        res=(0xFF>>(cnt+1))&*utf8;

    for (n=1;n<cnt;n++)
    {
        if ((utf8[n]&0xC0) != 0x80)
            return 0;
        if (!res && n==2 && !((utf8[n]&0x7F) >> (7 - cnt)))
            return 0;

        res=(res<<6)|(utf8[n]&0x3F);
    }

    wide = res;

    return cnt;
}

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

Definition at line 113 of file utf8.cpp.

{
    t_size count;

    if (wide < 0x80)
        count = 1;
    else if (wide < 0x800)
        count = 2;
    else if (wide < 0x10000)
        count = 3;
    else if (wide < 0x200000)
        count = 4;
    else if (wide < 0x4000000)
        count = 5;
    else if (wide <= 0x7FFFFFFF)
        count = 6;
    else
        return 0;
    //if (count>max) return 0;

    if (target == 0)
        return count;

    switch (count)
    {
    case 6:
        target[5] = 0x80 | (wide & 0x3F);
        wide = wide >> 6;
        wide |= 0x4000000;
    case 5:
        target[4] = 0x80 | (wide & 0x3F);
        wide = wide >> 6;
        wide |= 0x200000;
    case 4:
        target[3] = 0x80 | (wide & 0x3F);
        wide = wide >> 6;
        wide |= 0x10000;
    case 3:
        target[2] = 0x80 | (wide & 0x3F);
        wide = wide >> 6;
        wide |= 0x800;
    case 2:
        target[1] = 0x80 | (wide & 0x3F);
        wide = wide >> 6;
        wide |= 0xC0;
    case 1:
        target[0] = wide;
    }

    return count;
}

unsigned pfc::utf8_get_char

(

const char *

src

)

Definition at line 238 of file utf8.cpp.

{
    unsigned rv = 0;
    utf8_decode_char(src,rv);
    return rv;
}

t_size pfc::wcslen_max ( const wchar_t *  ptr, t_size  max  ) throw ( )

inline

Definition at line 92 of file string_base.h.

{return strlen_max_t(ptr,max);}

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

Definition at line 217 of file utf8.cpp.

                                                                                                      {
        PFC_STATIC_ASSERT( sizeof( wchar_t ) == sizeof( char16_t ) || sizeof( wchar_t ) == sizeof( unsigned ) );
        if (sizeof( wchar_t ) == sizeof( char16_t ) ) {
            return utf16_decode_char( reinterpret_cast< const char16_t *>(p_source), p_out, p_source_length );
        } else {
            if (p_source_length == 0) { * p_out = 0; return 0; }
            * p_out = p_source [ 0 ];
            return 1;
        }
    }

t_size pfc::wide_encode_char	(	unsigned	c,
		wchar_t *	out
	)
throw	(
	)

Definition at line 227 of file utf8.cpp.

                                                              {
        PFC_STATIC_ASSERT( sizeof( wchar_t ) == sizeof( char16_t ) || sizeof( wchar_t ) == sizeof( unsigned ) );
        if (sizeof( wchar_t ) == sizeof( char16_t ) ) {
            return utf16_encode_char( c, reinterpret_cast< char16_t * >(out) );
        } else {
            * out = (wchar_t) c;
            return 1;
        }
    }

BOOL pfc::winFormatSystemErrorMessage	(	pfc::string_base &	p_out,
		DWORD	p_code
	)

Definition at line 5 of file win-objects.cpp.

                                                                         {
    switch(p_code) {
    case ERROR_CHILD_NOT_COMPLETE:
        p_out = "Application cannot be run in Win32 mode.";
        return TRUE;
    case ERROR_INVALID_ORDINAL:
        p_out = "Invalid ordinal.";
        return TRUE;
    case ERROR_INVALID_STARTING_CODESEG:
        p_out = "Invalid code segment.";
        return TRUE;
    case ERROR_INVALID_STACKSEG:
        p_out = "Invalid stack segment.";
        return TRUE;
    case ERROR_INVALID_MODULETYPE:
        p_out = "Invalid module type.";
        return TRUE;
    case ERROR_INVALID_EXE_SIGNATURE:
        p_out = "Invalid executable signature.";
        return TRUE;
    case ERROR_BAD_EXE_FORMAT:
        p_out = "Not a valid Win32 application.";
        return TRUE;
    case ERROR_EXE_MACHINE_TYPE_MISMATCH:
        p_out = "Machine type mismatch.";
        return TRUE;
    case ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY:
    case ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY:
        p_out = "Unable to modify a signed binary.";
        return TRUE;
    default:
        {
            TCHAR temp[512];
            if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,0,p_code,0,temp,_countof(temp),0) == 0) return FALSE;
            for(t_size n=0;n<_countof(temp);n++) {
                switch(temp[n]) {
                case '\n':
                case '\r':
                    temp[n] = ' ';
                    break;
                }
            }
            p_out = stringcvt::string_utf8_from_os(temp,_countof(temp));
            return TRUE;
        }
        break;
    }
}

void pfc::winPrefixPath	(	pfc::string_base &	out,
		const char *	p_path
	)

Definition at line 53 of file win-objects.cpp.

                                                                 {
    const char * prepend_header = "\\\\?\\";
    const char * prepend_header_net = "\\\\?\\UNC\\";
    if (pfc::strcmp_partial( p_path, prepend_header ) == 0) { out = p_path; return; }
    out.reset();
    if (pfc::strcmp_partial(p_path,"\\\\") != 0) {
        out << prepend_header << p_path;
    } else {
        out << prepend_header_net << (p_path+2);
    }
};

void pfc::winUnPrefixPath	(	pfc::string_base &	out,
		const char *	p_path
	)

Definition at line 65 of file win-objects.cpp.

                                                                   {
    const char * prepend_header = "\\\\?\\";
    const char * prepend_header_net = "\\\\?\\UNC\\";
    if (pfc::strcmp_partial(p_path, prepend_header_net) == 0) {
        out = pfc::string_formatter() << "\\\\" << (p_path + strlen(prepend_header_net) );
        return;
    }
    if (pfc::strcmp_partial(p_path, prepend_header) == 0) {
        out = (p_path + strlen(prepend_header));
        return;
    }
    out = p_path;
}

GUID pfc::xorGUID ( const GUID &  v1, const GUID &  v2  )

inline

Definition at line 31 of file guid.h.

                                                          {
        GUID temp; memxor(&temp, &v1, &v2, sizeof(GUID)); return temp;
    }

Variable Documentation

const t_uint8 pfc::ascii_tolower_table[128] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F}

static

Definition at line 1091 of file string_base.cpp.

const bool pfc::byte_order_is_big_endian = !!PFC_BYTE_ORDER_IS_BIG_ENDIAN

static

Definition at line 116 of file byte_order_helper.h.

const bool pfc::byte_order_is_little_endian = !!PFC_BYTE_ORDER_IS_LITTLE_ENDIAN

static

Definition at line 117 of file byte_order_helper.h.

const fileHandle_t pfc::fileHandleInvalid = INVALID_HANDLE_VALUE

Definition at line 4 of file filehandle.h.

const GUID pfc::guid_null = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } }

Definition at line 171 of file guid.cpp.

const t_uint16 pfc::infinite16 = (t_uint16)(~0)

Definition at line 57 of file int_types.h.

const t_uint32 pfc::infinite32 = (t_uint32)(~0)

Definition at line 58 of file int_types.h.

const t_uint64 pfc::infinite64 = (t_uint64)(~0)

Definition at line 59 of file int_types.h.

const t_size pfc::infinite_size = (t_size)(~0)

Definition at line 60 of file int_types.h.

const t_uint8 pfc::mask_tab[6] ={0x80,0xE0,0xF0,0xF8,0xFC,0xFE}

static

Definition at line 6 of file utf8.cpp.

const t_rcptr_null pfc::rcptr_null = NULL

static

Definition at line 6 of file rcptr.h.

counter pfc::uniqueValCounter

static

Definition at line 145 of file sort.cpp.

const t_uint8 pfc::val_tab[6] ={0,0xC0,0xE0,0xF0,0xF8,0xFC}

static

Definition at line 8 of file utf8.cpp.

---

Generated by   1.8.9.1