pfc Namespace Reference


Classes

class  pfc::traits_t< file_info_impl_utils::info_entry >
class  pfc::traits_t< file_info_impl_utils::meta_entry >
class  pfc::traits_t< hasher_md5_state >
class  pfc::traits_t< hasher_md5_result >
class  pfc::traits_t< service_ptr_t< T > >
class  formatBugCheck
class  exception_bug_check_v2
class  alloc_dummy
class  alloc_simple
 Simple inefficient fully portable allocator. More...
class  __array_fast_helper_t
class  alloc_standard
class  alloc_fast
class  alloc_fast_aggressive
class  alloc_fixed
class  alloc_hybrid
class  pfc::traits_t< alloc_simple< t_item > >
class  pfc::traits_t< __array_fast_helper_t< t_item > >
class  pfc::traits_t< alloc_standard< t_item > >
class  pfc::traits_t< alloc_fast< t_item > >
class  pfc::traits_t< alloc_fast_aggressive< t_item > >
class  array_staticsize_t
 Special simplififed version of array class that avoids stepping on landmines with classes without public copy operators/constructors. More...
class  array_t
class  array_hybrid_t
class  pfc::traits_t< array_staticsize_t< t_item > >
class  pfc::traits_t< array_t< t_item, t_alloc > >
class  comparator_array
class  _avltree_node
class  avltree_t
class  pfc::traits_t< avltree_t< t_storage, t_comparator > >
class  binarySearch
class  bsearch_callback
class  bsearch_callback_impl_simple_t
class  bsearch_callback_impl_permutation_t
class  __EncodeIntHelper
class  pfc::__EncodeIntHelper< TInt, 1, IsBigEndian >
class  pfc::__EncodeIntHelper< TInt, 0, IsBigEndian >
class  __DecodeIntHelper
class  pfc::__DecodeIntHelper< TInt, 1, IsBigEndian >
class  pfc::__DecodeIntHelper< TInt, 0, IsBigEndian >
class  __chain_list_elem
class  chain_list_v2_t
class  pfc::traits_t< chain_list_v2_t< t_item > >
class  __chain_list_iterator_traits
class  pfc::traits_t< const_iterator< t_item > >
class  pfc::traits_t< iterator< t_item > >
class  GUID_from_text
class  print_guid
class  instance_tracker_server_t
class  instance_tracker_client_t
class  pfc::sized_int_t< 1 >
class  pfc::sized_int_t< 2 >
class  pfc::sized_int_t< 4 >
class  pfc::sized_int_t< 8 >
class  int_specs_signed_t
class  int_specs_unsigned_t
class  pfc::int_specs_t< char >
class  pfc::int_specs_t< unsigned char >
class  pfc::int_specs_t< short >
class  pfc::int_specs_t< unsigned short >
class  pfc::int_specs_t< int >
class  pfc::int_specs_t< unsigned int >
class  pfc::int_specs_t< long >
class  pfc::int_specs_t< unsigned long >
class  pfc::int_specs_t< long long >
class  pfc::int_specs_t< unsigned long long >
class  pfc::int_specs_t< wchar_t >
class  _list_node
 Base class for list nodes. Implemented by list implementers. More...
class  const_iterator
class  iterator
class  comparator_list
class  list_base_const_t
class  list_single_ref_t
class  list_partial_ref_t
class  list_const_array_t
class  list_const_cast_t
class  ptr_list_const_array_t
class  list_const_ptr_t
class  list_base_t
class  list_impl_t
class  list_t
class  list_hybrid_t
class  ptr_list_const_cast_t
class  list_const_permutation_t
class  list_permutation_t
class  __map_overwrite_wrapper
class  map_t
class  vartoggle_t
class  releaser_delete
class  releaser_delete_array
class  releaser_free
class  ptrholder_t
 Assumes t_freefunc to never throw exceptions. More...
class  pfc::ptrholder_t< void, t_releaser >
class  int_container_helper
class  instanceTracker
class  instanceTrackerV2
class  __exception_with_message_t
class  pfc::assert_same_type< p_type, p_type >
class  is_same_type
class  pfc::is_same_type< p_type, p_type >
class  pfc::static_assert< true >
class  pfc::static_assert_t< true >
class  pfc::assert_byte_type< t_uint8 >
class  pfc::assert_byte_type< t_int8 >
class  exception_overflow
class  exception_bug_check
class  exception_invalid_params
class  exception_unexpected_recursion
class  exception_not_implemented
class  exception_dynamic_assert
class  comparator_default
 For use with avltree/map etc. More...
class  comparator_pointer
class  comparator_dual
class  comparator_memcmp
class  __list_to_array_enumerator
class  enumerator_add_item
class  ptr_list_t
class  ptr_list_hybrid_t
class  rc_container_base
class  rc_container_t
class  rcptr_t
class  traits_rcptr
class  pfc::traits_t< rcptr_t< T > >
class  counter
class  refcounted_object_root
class  refcounted_object_ptr_t
class  pfc::traits_t< refcounted_object_ptr_t< T > >
class  reorder_callback
class  reorder_callback_impl_t
class  reorder_callback_impl_delta
class  reorder_callback_impl_ptr_t
class  sort_callback
class  sort_callback_stabilizer
class  sort_callback_impl_simple_wrap_t
class  sort_callback_impl_auto_wrap_t
class  sort_callback_impl_permutation_wrap_t
class  string_receiver
class  string_base
class  string_fixed_t
class  string8_t
class  pfc::traits_t< string8_t< t_alloc > >
class  string_buffer
class  format_time
class  format_time_ex
class  string_filename
class  string_filename_ext
class  string_extension
class  string_replace_extension
class  string_directory
class  format_float
class  format_int
class  format_uint
class  format_hex
class  format_hex_lowercase
class  format_hexdump_ex
class  format_hexdump
class  format_hexdump_lowercase
class  format_fixedpoint
class  format_char
class  format_pad_left
class  format_pad_right
class  format_array
class  format_file_size_short
class  string_simple_t
class  pfc::traits_t< string_simple_t< t_char > >
class  comparator_strcmp
class  comparator_stricmp_ascii
class  __splitStringSimple_calculateSubstringCount
class  __splitStringSimple_check
class  __splitStringSimple_arrayWrapper
class  __splitStringSimple_listWrapper
class  string_base_ref
class  string_list_impl
class  __stringEmpty
class  string
class  stringp
 "String parameter" helper class, to use in function parameters, allowing functions to take any type of string as a parameter (const char*, string_base, string). More...
class  traits_default
class  traits_default_movable
class  traits_rawobject
class  traits_vtable
class  traits_t
class  combine_traits
class  traits_combined
class  pfc::traits_t< T * >
class  pfc::traits_t< char >
class  pfc::traits_t< unsigned char >
class  pfc::traits_t< wchar_t >
class  pfc::traits_t< short >
class  pfc::traits_t< unsigned short >
class  pfc::traits_t< int >
class  pfc::traits_t< unsigned int >
class  pfc::traits_t< long >
class  pfc::traits_t< unsigned long >
class  pfc::traits_t< long long >
class  pfc::traits_t< unsigned long long >
class  pfc::traits_t< bool >
class  pfc::traits_t< float >
class  pfc::traits_t< double >
class  pfc::traits_t< GUID >
class  pfc::traits_t< T[p_count]>

Namespaces

namespace  io

Typedefs

typedef vartoggle_t< bool > booltoggle
typedef std::exception exception
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 string_simple_t< char > string_simple
typedef list_base_const_t
< const char * > 
string_list_const

Enumerations

enum  { byte_order_is_big_endian = 0, byte_order_is_little_endian = (!( 0 )) }

Functions

static void * raw_malloc (t_size p_size)
static void raw_free (void *p_block) throw ()
static void * raw_realloc (void *p_ptr, t_size p_size)
static bool raw_realloc_inplace (void *p_block, t_size p_size) throw ()
template<typename T>
t_size calc_array_width (t_size p_width)
template<typename T>
T * __raw_malloc_t (t_size p_size)
template<typename T>
void __raw_free_t (T *p_block) throw ()
template<typename T>
T * __raw_realloc_t (T *p_block, t_size p_size)
template<typename T>
bool __raw_realloc_inplace_t (T *p_block, t_size p_size)
template<typename t_exception, typename t_int>
t_int safe_shift_left_t (t_int p_val, t_size p_shift=1)
template<typename t_item>
bool is_pointer_in_range (const t_item *p_buffer, t_size p_buffer_size, const void *p_pointer)
template<typename t_to, typename t_from>
void copy_array_t (t_to &p_to, const t_from &p_from)
template<typename t_array, typename t_value>
void fill_array_t (t_array &p_array, const t_value &p_value)
bool bsearch (t_size p_count, bsearch_callback const &p_callback, t_size &p_result)
template<typename t_container, typename t_compare, typename t_param>
bool bsearch_t (t_size p_count, const t_container &p_container, t_compare p_compare, const t_param &p_param, t_size &p_index)
template<typename t_container, typename t_compare, typename t_param, typename t_permutation>
bool bsearch_permutation_t (t_size p_count, const t_container &p_container, t_compare p_compare, const t_param &p_param, const t_permutation &p_permutation, t_size &p_index)
template<typename t_container, typename t_compare, typename t_param>
bool bsearch_range_t (const t_size p_count, const t_container &p_container, t_compare p_compare, const t_param &p_param, t_size &p_range_base, t_size &p_range_count)
template<typename t_callback>
bool bsearch_inline_t (t_size p_count, const t_callback &p_callback, t_size &p_result)
template<typename t_buffer, typename t_value>
bool bsearch_simple_inline_t (const t_buffer &p_buffer, t_size p_count, t_value const &p_value, t_size &p_result)
void byteswap_raw (void *p_buffer, t_size p_bytes)
template<typename T>
byteswap_t (T p_source)
template<>
char byteswap_t< char > (char p_source)
template<>
unsigned char byteswap_t< unsigned char > (unsigned char p_source)
template<>
t_uint16 byteswap_t< t_uint16 > (t_uint16 p_source)
template<>
t_int16 byteswap_t< t_int16 > (t_int16 p_source)
template<>
t_uint32 byteswap_t< t_uint32 > (t_uint32 p_source)
template<>
t_int32 byteswap_t< t_int32 > (t_int32 p_source)
template<>
t_uint64 byteswap_t< t_uint64 > (t_uint64 p_source)
template<>
t_int64 byteswap_t< t_int64 > (t_int64 p_source)
template<>
wchar_t byteswap_t< wchar_t > (wchar_t p_source)
template<>
float byteswap_t< float > (float p_source)
template<>
double byteswap_t< double > (double p_source)
template<>
GUID byteswap_t< GUID > (GUID p_guid)
template<typename T>
byteswap_if_be_t (T p_param)
template<typename T>
byteswap_if_le_t (T p_param)
template<typename TInt>
void encode_little_endian (t_uint8 *p_buffer, TInt p_value)
template<typename TInt>
void encode_big_endian (t_uint8 *p_buffer, TInt p_value)
template<typename TInt>
void decode_little_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt>
void decode_big_endian (TInt &p_out, const t_uint8 *p_buffer)
template<typename TInt>
TInt decode_little_endian (const t_uint8 *p_buffer)
template<typename TInt>
TInt decode_big_endian (const t_uint8 *p_buffer)
template<bool IsBigEndian, typename TInt>
void decode_endian (TInt &p_out, const t_uint8 *p_buffer)
template<bool IsBigEndian, typename TInt>
void encode_endian (t_uint8 *p_buffer, TInt p_in)
template<unsigned width>
static void reverse_bytes (t_uint8 *p_buffer)
template<>
static void reverse_bytes< 1 > (t_uint8 *p_buffer)
template<>
static void reverse_bytes< 0 > (t_uint8 *p_buffer)
int guid_compare (const GUID &g1, const GUID &g2)
bool guid_equal (const GUID &g1, const GUID &g2)
template<>
int compare_t< GUID, GUID > (const GUID &p_item1, const GUID &p_item2)
void print_hex_raw (const void *buffer, unsigned bytes, char *p_out)
static 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)
static GUID xorGUID (const GUID &v1, const GUID &v2)
template<typename t_list1, typename t_list2>
static bool listEquals (const t_list1 &p_list1, const t_list2 &p_list2)
 PFC_DECLARE_EXCEPTION (exception_map_entry_not_found, exception,"Map entry not found")
 PFC_DECLARE_EXCEPTION (exception_invalid_permutation, exception_invalid_params,"Invalid permutation")
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)
 For critical sanity checks. Speed: O(n), allocates memory.
void permutation_validate (t_size const *order, t_size count)
 For critical sanity checks. Speed: O(n), allocates memory.
void 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.
template<typename t_list>
static bool guess_reorder_pattern (pfc::array_t< t_size > &out, const t_list &from, const t_list &to)
void crash ()
template<typename t_exception>
void throw_exception_with_message (const char *p_message)
template<typename t_type>
void assert_raw_type ()
template<typename t_type>
void __unsafe__memcpy_t (t_type *p_dst, const t_type *p_src, t_size p_count)
template<typename t_type>
void __unsafe__in_place_destructor_t (t_type &p_item) throw ()
template<typename t_type>
void __unsafe__in_place_constructor_t (t_type &p_item)
template<typename t_type>
void __unsafe__in_place_destructor_array_t (t_type *p_items, t_size p_count) throw ()
template<typename t_type>
t_type * __unsafe__in_place_constructor_array_t (t_type *p_items, t_size p_count)
template<typename t_type>
t_type * __unsafe__in_place_resize_array_t (t_type *p_items, t_size p_from, t_size p_to)
template<typename t_type, typename t_copy>
void __unsafe__in_place_constructor_copy_t (t_type &p_item, const t_copy &p_copyfrom)
template<typename t_type, typename t_copy>
t_type * __unsafe__in_place_constructor_array_copy_t (t_type *p_items, t_size p_count, const t_copy *p_copyfrom)
template<typename t_type, typename t_copy>
t_type * __unsafe__in_place_constructor_array_copy_partial_t (t_type *p_items, t_size p_count, const t_copy *p_copyfrom, t_size p_copyfrom_count)
template<typename t_ret>
t_ret safe_cast (t_ret val)
template<typename t_ret, typename t_param>
t_ret * safe_ptr_cast (t_param *p_param)
template<typename t_ret, typename t_param>
t_ret downcast_guarded (const t_param &p_param)
template<typename t_exception, typename t_ret, typename t_param>
t_ret downcast_guarded_ex (const t_param &p_param)
template<typename t_acc, typename t_add>
void accumulate_guarded (t_acc &p_acc, const t_add &p_add)
void bug_check_assert (bool p_condition, const char *p_msg)
void bug_check_assert (bool p_condition)
void dynamic_assert (bool p_condition, const char *p_msg)
void dynamic_assert (bool p_condition)
template<typename T>
void swap_multi_t (T *p_buffer1, T *p_buffer2, t_size p_size)
template<typename T, t_size p_size>
void swap_multi_t (T *p_buffer1, T *p_buffer2)
template<t_size p_size>
void __unsafe__swap_raw_t (void *p_object1, void *p_object2)
template<typename T>
void swap_t (T &p_item1, T &p_item2)
template<typename t_array>
t_size array_size_t (const t_array &p_array)
template<typename t_item, t_size p_width>
t_size array_size_t (const t_item(&p_array)[p_width])
template<typename t_array, typename t_filler>
void fill_t (t_array &p_buffer, const t_size p_count, const t_filler &p_filler)
template<typename t_array, typename t_filler>
void fill_ptr_t (t_array *p_buffer, const t_size p_count, const t_filler &p_filler)
template<typename t_item1, typename t_item2>
int compare_t (const t_item1 &p_item1, const t_item2 &p_item2)
template<typename t_source1, typename t_source2>
t_size subtract_sorted_lists_calculate_count (const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_destination, typename t_source1, typename t_source2>
void subtract_sorted_lists (t_destination &p_destination, const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_source1, typename t_source2>
t_size merge_sorted_lists_calculate_count (const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_destination, typename t_source1, typename t_source2>
void merge_sorted_lists (t_destination &p_destination, const t_source1 &p_source1, const t_source2 &p_source2)
template<typename t_array, typename T>
t_size append_t (t_array &p_array, const T &p_item)
template<typename t_array, typename T>
t_size append_swap_t (t_array &p_array, T &p_item)
template<typename t_array, typename T>
t_size insert_t (t_array &p_array, const T &p_item, t_size p_index)
template<typename t_array>
t_size insert_default_t (t_array &p_array, 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>
max_t (const T &item1, const T &item2)
template<typename T>
min_t (const T &item1, const T &item2)
template<typename T>
abs_t (T item)
template<typename T>
sqr_t (T item)
template<typename T>
clip_t (const T &p_item, const T &p_min, const T &p_max)
template<typename T>
void delete_t (T *ptr)
template<typename T>
void delete_array_t (T *ptr)
template<typename T>
T * clone_t (T *ptr)
template<typename t_exception, typename t_int>
t_int mul_safe_t (t_int p_val1, t_int p_val2)
template<typename t_int>
t_int multiply_guarded (t_int v1, t_int v2)
template<typename t_src, typename t_dst>
void memcpy_t (t_dst *p_dst, const t_src *p_src, t_size p_count)
template<typename t_dst, typename t_src>
void copy_array_loop_t (t_dst &p_dst, const t_src &p_src, t_size p_count)
template<typename t_src, typename t_dst>
void memcpy_backwards_t (t_dst *p_dst, const t_src *p_src, t_size p_count)
template<typename T, typename t_val>
void memset_t (T *p_buffer, const t_val &p_val, t_size p_count)
template<typename T, typename t_val>
void memset_t (T &p_buffer, const t_val &p_val)
template<typename T>
void memset_null_t (T *p_buffer, t_size p_count)
template<typename T>
void memset_null_t (T &p_buffer)
template<typename T>
void memmove_t (T *p_dst, const T *p_src, t_size p_count)
template<typename TVal>
void memxor_t (TVal *out, const TVal *s1, const TVal *s2, t_size count)
static void memxor (void *target, const void *source1, const void *source2, t_size size)
template<typename T>
T * new_ptr_check_t (T *p_ptr)
template<typename T>
int sgn_t (const T &p_val)
template<typename T>
const T * empty_string_t ()
template<>
const char * empty_string_t< char > ()
template<>
const wchar_t * empty_string_t< wchar_t > ()
template<typename t_type, typename t_newval>
t_type replace_t (t_type &p_var, const t_newval &p_newval)
template<typename t_type>
t_type replace_null_t (t_type &p_var)
template<t_size p_size_pow2>
bool is_ptr_aligned_t (const void *p_ptr)
template<typename t_array>
void array_rangecheck_t (const t_array &p_array, t_size p_index)
template<typename t_array>
void array_rangecheck_t (const t_array &p_array, t_size p_from, t_size p_to)
t_int32 rint32 (double p_val)
t_int64 rint64 (double p_val)
template<typename t_array>
t_size remove_mask_t (t_array &p_array, const bit_array &p_mask)
template<typename t_array, typename t_compare>
t_size find_duplicates_sorted_t (t_array p_array, t_size p_count, t_compare p_compare, bit_array_var &p_out)
template<typename t_array, typename t_compare, typename t_permutation>
t_size find_duplicates_sorted_permutation_t (t_array p_array, t_size p_count, t_compare p_compare, t_permutation const &p_permutation, bit_array_var &p_out)
template<typename t_char>
t_size strlen_t (const t_char *p_string, t_size p_length=infinite)
template<typename t_list, typename t_array>
void list_to_array (t_array &p_array, const t_list &p_list)
template<typename t_receiver, typename t_giver>
void overwrite_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
template<typename t_receiver, typename t_giver>
void copy_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
bool lxor (bool p_val1, bool p_val2)
template<typename t_val>
void min_acc (t_val &p_acc, const t_val &p_val)
template<typename t_val>
void max_acc (t_val &p_acc, const t_val &p_val)
t_uint64 pow_int (t_uint64 base, t_uint64 exp)
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 swap_void (void *item1, void *item2, t_size width)
void reorder_void (void *data, t_size width, const t_size *order, t_size num, void(*swapfunc)(void *item1, void *item2, t_size width)=swap_void)
void reorder (reorder_callback &p_callback, const t_size *p_order, t_size p_count)
template<typename t_container>
void reorder_t (t_container &p_data, const t_size *p_order, t_size p_count)
template<typename t_container>
void reorder_partial_t (t_container &p_data, t_size p_base, const t_size *p_order, t_size p_count)
template<typename T>
void reorder_ptr_t (T *p_data, const t_size *p_order, t_size p_count)
void sort (sort_callback &p_callback, t_size p_count)
void sort_stable (sort_callback &p_callback, t_size p_count)
void sort_void_ex (void *base, t_size num, t_size width, int(*comp)(const void *, const void *), void(*swap)(void *, void *, t_size))
void sort_void (void *base, t_size num, t_size width, int(*comp)(const void *, const void *))
template<typename t_container, typename t_compare>
static void sort_t (t_container &p_data, t_compare p_compare, t_size p_count)
template<typename t_container, typename t_compare>
static void sort_stable_t (t_container &p_data, t_compare p_compare, t_size p_count)
template<typename t_container, typename t_compare, typename t_permutation>
static void sort_get_permutation_t (const t_container &p_data, t_compare p_compare, t_size p_count, t_permutation const &p_permutation)
template<typename t_container, typename t_compare, typename t_permutation>
static void sort_stable_get_permutation_t (const t_container &p_data, t_compare p_compare, t_size p_count, t_permutation const &p_permutation)
t_size scan_filename (const char *ptr)
bool is_path_separator (unsigned c)
bool is_path_bad_char (unsigned c)
bool is_valid_utf8 (const char *param, t_size max=infinite)
bool is_lower_ascii (const char *param)
bool is_multiline (const char *p_string, t_size p_len=infinite)
bool has_path_bad_chars (const char *param)
void recover_invalid_utf8 (const char *src, char *out, unsigned replace)
void convert_to_lower_ascii (const char *src, t_size max, char *out, char replace= '?')
char ascii_tolower (char c)
char ascii_toupper (char c)
t_size string_find_first (const char *p_string, char p_tofind, t_size p_start=0)
t_size string_find_last (const char *p_string, char p_tofind, t_size p_start=~0)
t_size string_find_first (const char *p_string, const char *p_tofind, t_size p_start=0)
t_size string_find_last (const char *p_string, const char *p_tofind, t_size p_start=~0)
t_size string_find_first_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start=0)
t_size string_find_last_ex (const char *p_string, t_size p_string_length, char p_tofind, t_size p_start=~0)
t_size string_find_first_ex (const char *p_string, t_size p_string_length, const char *p_tofind, t_size p_tofind_length, t_size p_start=0)
t_size string_find_last_ex (const char *p_string, t_size p_string_length, const char *p_tofind, t_size p_tofind_length, t_size p_start=~0)
template<typename t_char>
t_size strlen_max_t (const t_char *ptr, t_size max)
t_size strlen_max (const char *ptr, t_size max) throw ()
t_size wcslen_max (const wchar_t *ptr, t_size max) throw ()
bool string_is_numeric (const char *p_string, t_size p_length=infinite) throw ()
bool char_is_numeric (char p_char) throw ()
bool char_is_ascii_alpha_upper (char p_char) throw ()
bool char_is_ascii_alpha_lower (char p_char) throw ()
bool char_is_ascii_alpha (char p_char) throw ()
bool char_is_ascii_alphanumeric (char p_char) throw ()
unsigned atoui_ex (const char *ptr, t_size max)
t_int64 atoi64_ex (const char *ptr, t_size max)
t_uint64 atoui64_ex (const char *ptr, t_size max)
t_size strlen_utf8 (const char *s, t_size num=~0) throw ()
t_size utf8_char_len (const char *s, t_size max=~0) throw ()
t_size utf8_char_len_from_header (char c) throw ()
t_size utf8_chars_to_bytes (const char *string, t_size count) throw ()
t_size strcpy_utf8_truncate (const char *src, char *out, t_size maxbytes)
t_size utf8_decode_char (const char *src, unsigned &out, t_size src_bytes) throw ()
t_size utf8_decode_char (const char *src, unsigned &out) throw ()
t_size utf8_encode_char (unsigned c, char *out) 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, wchar_t *out) throw ()
t_size strstr_ex (const char *p_string, t_size p_string_len, const char *p_substring, t_size p_substring_len) throw ()
t_size skip_utf8_chars (const char *ptr, t_size count) throw ()
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 *s1, t_size len1, const char *s2, t_size len2) throw ()
int strcmp_ex (const char *p1, t_size n1, const char *p2, t_size n2) throw ()
unsigned utf8_get_char (const char *src)
bool utf8_advance (const char *&var) throw ()
bool utf8_advance (char *&var) throw ()
const char * utf8_char_next (const char *src) throw ()
char * utf8_char_next (char *src) throw ()
class PFC_DEPRECATE ("Use string8/string_fixed_t with operator<< overloads instead.") string_printf
void float_to_string (char *out, t_size out_max, double val, unsigned precision, bool force_sign=false)
double string_to_float (const char *src, t_size len=infinite)
template<>
void swap_t (string8 &p_item1, string8 &p_item2)
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=infinite)
template<typename t_array>
void splitStringSimple_toArray (t_array &p_output, const char *p_splitChars, const char *p_string, t_size p_stringLen=infinite)
template<typename t_list>
void splitStringSimple_toList (t_list &p_output, const char *p_splitChars, const char *p_string, t_size p_stringLen=infinite)
template<typename t_out>
void splitStringByLines (t_out &out, const char *str)
void stringToUpperAppend (string_base &p_out, const char *p_source, t_size p_sourceLen)
void stringToLowerAppend (string_base &p_out, const char *p_source, t_size p_sourceLen)
int stringCompareCaseInsensitive (const char *s1, const char *s2)
t_uint32 charLower (t_uint32 param)
t_uint32 charUpper (t_uint32 param)
template<typename T>
const char * stringToPtr (T const &val)
const char * stringToPtr (const char *val)
template<typename TChar, t_size len, typename TSource>
void 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.
template<typename TChar, t_size len, typename TSource>
void 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.
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 ()
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 ()
static int strcmp_partial_ex (const char *str, t_size strLen, const char *substr, t_size substrLen) throw ()
static int strcmp_partial (const char *str, const char *substr) throw ()
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)
template<typename TList>
string stringCombineList (const TList &list, stringp separator)
t_size getOptimalWorkerThreadCount ()
t_size getOptimalWorkerThreadCountEx (t_size taskCountLimit)

Variables

const GUID guid_null


Typedef Documentation

typedef std::exception pfc::exception

typedef ptr_list_t<void> pfc::ptr_list


Enumeration Type Documentation

anonymous enum

Enumerator:
byte_order_is_big_endian 
byte_order_is_little_endian 


Function Documentation

template<typename T>
void pfc::__raw_free_t ( T *  p_block  )  throw () [inline]

template<typename T>
T* pfc::__raw_malloc_t ( t_size  p_size  )  [inline]

template<typename T>
bool pfc::__raw_realloc_inplace_t ( T *  p_block,
t_size  p_size 
) [inline]

template<typename T>
T* pfc::__raw_realloc_t ( T *  p_block,
t_size  p_size 
) [inline]

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

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

template<typename t_type>
t_type* pfc::__unsafe__in_place_constructor_array_t ( t_type *  p_items,
t_size  p_count 
) [inline]

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

template<typename t_type>
void pfc::__unsafe__in_place_constructor_t ( t_type &  p_item  )  [inline]

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

template<typename t_type>
void pfc::__unsafe__in_place_destructor_t ( t_type &  p_item  )  throw () [inline]

template<typename t_type>
t_type* pfc::__unsafe__in_place_resize_array_t ( t_type *  p_items,
t_size  p_from,
t_size  p_to 
) [inline]

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

template<t_size p_size>
void pfc::__unsafe__swap_raw_t ( void *  p_object1,
void *  p_object2 
) [inline]

template<typename t_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 () [inline]

template<typename T>
T pfc::abs_t ( item  )  [inline]

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

template<typename t_array, typename T>
t_size pfc::append_swap_t ( t_array &  p_array,
T &  p_item 
) [inline]

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

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

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

template<typename t_item, t_size p_width>
t_size pfc::array_size_t ( const t_item(&)  p_array[p_width]  )  [inline]

template<typename t_array>
t_size pfc::array_size_t ( const t_array &  p_array  )  [inline]

char pfc::ascii_tolower ( char  c  )  [inline]

char pfc::ascii_toupper ( char  c  )  [inline]

template<typename t_type>
void pfc::assert_raw_type (  )  [inline]

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

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

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

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

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

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

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

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

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

void pfc::bug_check_assert ( bool  p_condition  )  [inline]

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

template<typename T>
T pfc::byteswap_if_be_t ( p_param  )  [inline]

template<typename T>
T pfc::byteswap_if_le_t ( p_param  )  [inline]

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

template<typename T>
T pfc::byteswap_t ( p_source  )  [inline]

template<>
char pfc::byteswap_t< char > ( char  p_source  )  [inline]

template<>
double pfc::byteswap_t< double > ( double  p_source  )  [inline]

template<>
float pfc::byteswap_t< float > ( float  p_source  )  [inline]

template<>
GUID pfc::byteswap_t< GUID > ( GUID  p_guid  )  [inline]

template<>
t_int16 pfc::byteswap_t< t_int16 > ( t_int16  p_source  )  [inline]

template<>
t_int32 pfc::byteswap_t< t_int32 > ( t_int32  p_source  )  [inline]

template<>
t_int64 pfc::byteswap_t< t_int64 > ( t_int64  p_source  )  [inline]

template<>
t_uint16 pfc::byteswap_t< t_uint16 > ( t_uint16  p_source  )  [inline]

template<>
t_uint32 pfc::byteswap_t< t_uint32 > ( t_uint32  p_source  )  [inline]

template<>
t_uint64 pfc::byteswap_t< t_uint64 > ( t_uint64  p_source  )  [inline]

template<>
unsigned char pfc::byteswap_t< unsigned char > ( unsigned char  p_source  )  [inline]

template<>
wchar_t pfc::byteswap_t< wchar_t > ( wchar_t  p_source  )  [inline]

template<typename T>
t_size pfc::calc_array_width ( t_size  p_width  )  [inline]

bool pfc::char_is_ascii_alpha ( char  p_char  )  throw () [inline]

bool pfc::char_is_ascii_alpha_lower ( char  p_char  )  throw () [inline]

bool pfc::char_is_ascii_alpha_upper ( char  p_char  )  throw () [inline]

bool pfc::char_is_ascii_alphanumeric ( char  p_char  )  throw () [inline]

bool pfc::char_is_numeric ( char  p_char  )  throw () [inline]

t_uint32 pfc::charLower ( t_uint32  param  ) 

t_uint32 pfc::charUpper ( t_uint32  param  ) 

template<typename T>
T pfc::clip_t ( const T &  p_item,
const T &  p_min,
const T &  p_max 
) [inline]

template<typename T>
T* pfc::clone_t ( T *  ptr  )  [inline]

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

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

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

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

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

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

void pfc::crash (  ) 

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.

template<typename TInt>
TInt pfc::decode_big_endian ( const t_uint8 p_buffer  )  [inline]

template<typename TInt>
void pfc::decode_big_endian ( TInt &  p_out,
const t_uint8 p_buffer 
) [inline]

template<bool IsBigEndian, typename TInt>
void pfc::decode_endian ( TInt &  p_out,
const t_uint8 p_buffer 
) [inline]

template<typename TInt>
TInt pfc::decode_little_endian ( const t_uint8 p_buffer  )  [inline]

template<typename TInt>
void pfc::decode_little_endian ( TInt &  p_out,
const t_uint8 p_buffer 
) [inline]

template<typename T>
void pfc::delete_array_t ( T *  ptr  )  [inline]

template<typename T>
void pfc::delete_t ( T *  ptr  )  [inline]

template<typename t_ret, typename t_param>
t_ret pfc::downcast_guarded ( const t_param &  p_param  )  [inline]

template<typename t_exception, typename t_ret, typename t_param>
t_ret pfc::downcast_guarded_ex ( const t_param &  p_param  )  [inline]

void pfc::dynamic_assert ( bool  p_condition  )  [inline]

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

template<typename T>
const T* pfc::empty_string_t (  )  [inline]

template<>
const char* pfc::empty_string_t< char > (  )  [inline]

template<>
const wchar_t* pfc::empty_string_t< wchar_t > (  )  [inline]

template<typename TInt>
void pfc::encode_big_endian ( t_uint8 p_buffer,
TInt  p_value 
) [inline]

template<bool IsBigEndian, typename TInt>
void pfc::encode_endian ( t_uint8 p_buffer,
TInt  p_in 
) [inline]

template<typename TInt>
void pfc::encode_little_endian ( t_uint8 p_buffer,
TInt  p_value 
) [inline]

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

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

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

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

template<typename t_array, typename t_compare>
t_size pfc::find_duplicates_sorted_t ( t_array  p_array,
t_size  p_count,
t_compare  p_compare,
bit_array_var p_out 
) [inline]

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

t_size pfc::getOptimalWorkerThreadCount (  ) 

t_size pfc::getOptimalWorkerThreadCountEx ( t_size  taskCountLimit  ) 

template<typename t_list>
static bool pfc::guess_reorder_pattern ( pfc::array_t< t_size > &  out,
const t_list &  from,
const t_list &  to 
) [inline, static]

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

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

bool pfc::has_path_bad_chars ( const char *  param  ) 

template<typename t_array>
t_size pfc::insert_default_t ( t_array &  p_array,
t_size  p_index 
) [inline]

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

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

bool pfc::is_lower_ascii ( const char *  param  ) 

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

bool pfc::is_path_bad_char ( unsigned  c  ) 

bool pfc::is_path_separator ( unsigned  c  ) 

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

template<t_size p_size_pow2>
bool pfc::is_ptr_aligned_t ( const void *  p_ptr  )  [inline]

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

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

template<typename t_list1, typename t_list2>
static bool pfc::listEquals ( const t_list1 &  p_list1,
const t_list2 &  p_list2 
) [inline, static]

bool pfc::lxor ( bool  p_val1,
bool  p_val2 
) [inline]

static 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 
) [static]

template<typename t_val>
void pfc::max_acc ( t_val &  p_acc,
const t_val &  p_val 
) [inline]

template<typename T>
T pfc::max_t ( const T &  item1,
const T &  item2 
) [inline]

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

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

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

template<typename T>
void pfc::memset_null_t ( T &  p_buffer  )  [inline]

template<typename T>
void pfc::memset_null_t ( T *  p_buffer,
t_size  p_count 
) [inline]

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

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

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

template<typename TVal>
void pfc::memxor_t ( TVal *  out,
const TVal *  s1,
const TVal *  s2,
t_size  count 
) [inline]

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

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

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

template<typename t_val>
void pfc::min_acc ( t_val &  p_acc,
const t_val &  p_val 
) [inline]

template<typename T>
T pfc::min_t ( const T &  item1,
const T &  item2 
) [inline]

template<typename t_exception, typename t_int>
t_int pfc::mul_safe_t ( t_int  p_val1,
t_int  p_val2 
) [inline]

template<typename t_int>
t_int pfc::multiply_guarded ( t_int  v1,
t_int  v2 
) [inline]

template<typename T>
T* pfc::new_ptr_check_t ( T *  p_ptr  )  [inline]

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

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

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

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

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

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

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

class pfc::PFC_DEPRECATE ( "Use string8/string_fixed_t with operator<< overloads instead."   ) 

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

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

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

static void* pfc::raw_malloc ( t_size  p_size  )  [static]

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

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

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

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

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

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

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

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

template<typename t_object>
rcptr_t<t_object> pfc::rcnew_t (  )  [inline]

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

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

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

template<typename t_container>
void pfc::reorder_partial_t ( t_container &  p_data,
t_size  p_base,
const t_size p_order,
t_size  p_count 
) [inline]

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

template<typename t_container>
void pfc::reorder_t ( t_container &  p_data,
const t_size p_order,
t_size  p_count 
) [inline]

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

template<typename t_type>
t_type pfc::replace_null_t ( t_type &  p_var  )  [inline]

template<typename t_type, typename t_newval>
t_type pfc::replace_t ( t_type &  p_var,
const t_newval &  p_newval 
) [inline]

template<unsigned width>
static void pfc::reverse_bytes ( t_uint8 p_buffer  )  [inline, static]

template<>
static void pfc::reverse_bytes< 0 > ( t_uint8 p_buffer  )  [inline, static]

template<>
static void pfc::reverse_bytes< 1 > ( t_uint8 p_buffer  )  [inline, static]

t_int32 pfc::rint32 ( double  p_val  )  [inline]

t_int64 pfc::rint64 ( double  p_val  )  [inline]

template<typename t_ret>
t_ret pfc::safe_cast ( t_ret  val  )  [inline]

template<typename t_ret, typename t_param>
t_ret* pfc::safe_ptr_cast ( t_param *  p_param  )  [inline]

template<typename t_exception, typename t_int>
t_int pfc::safe_shift_left_t ( t_int  p_val,
t_size  p_shift = 1 
) [inline]

t_size pfc::scan_filename ( const char *  ptr  ) 

template<typename T>
int pfc::sgn_t ( const T &  p_val  )  [inline]

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

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

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

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

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

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

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

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

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

template<typename t_out>
void pfc::splitStringByLines ( t_out &  out,
const char *  str 
) [inline]

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 = infinite 
) [inline]

template<typename t_array>
void pfc::splitStringSimple_toArray ( t_array &  p_output,
const char *  p_splitChars,
const char *  p_string,
t_size  p_stringLen = infinite 
) [inline]

template<typename t_list>
void pfc::splitStringSimple_toList ( t_list &  p_output,
const char *  p_splitChars,
const char *  p_string,
t_size  p_stringLen = infinite 
) [inline]

template<typename T>
T pfc::sqr_t ( item  )  [inline]

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

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

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

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 () [inline]

template<typename t_char>
int pfc::strcmp_partial_t ( const t_char *  p_string,
const t_char *  p_substring 
) throw () [inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename TList>
string pfc::stringCombineList ( const TList &  list,
stringp  separator 
) [inline]

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

template<typename TChar, t_size len, typename TSource>
void pfc::stringToBuffer ( TChar(&)  buffer[len],
const TSource &  source 
) [inline]

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

template<typename TChar, t_size len, typename TSource>
void pfc::stringToBufferGuarded ( TChar(&)  buffer[len],
const TSource &  source 
) [inline]

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

void pfc::stringToLowerAppend ( string_base &  p_out,
const char *  p_source,
t_size  p_sourceLen 
)

const char* pfc::stringToPtr ( const char *  val  )  [inline]

template<typename T>
const char* pfc::stringToPtr ( T const &  val  )  [inline]

void pfc::stringToUpperAppend ( string_base &  p_out,
const char *  p_source,
t_size  p_sourceLen 
)

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

template<typename t_char>
t_size pfc::strlen_max_t ( const t_char *  ptr,
t_size  max 
) [inline]

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

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

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

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

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

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

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

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

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

template<typename T>
void pfc::swap_t ( T &  p_item1,
T &  p_item2 
) [inline]

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

template<typename t_exception>
void pfc::throw_exception_with_message ( const char *  p_message  )  [inline]

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

template<>
string pfc::toString ( char const &  val  )  [inline]

template<>
string pfc::toString ( double const &  val  )  [inline]

template<>
string pfc::toString ( float const &  val  )  [inline]

template<>
string pfc::toString ( t_uint16 const &  val  )  [inline]

template<>
string pfc::toString ( t_uint32 const &  val  )  [inline]

template<>
string pfc::toString ( t_uint64 const &  val  )  [inline]

template<>
string pfc::toString ( t_int16 const &  val  )  [inline]

template<>
string pfc::toString ( t_int32 const &  val  )  [inline]

template<>
string pfc::toString ( t_int64 const &  val  )  [inline]

template<typename T>
string pfc::toString ( T const &  val  )  [inline]

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

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

bool pfc::utf8_advance ( char *&  var  )  throw () [inline]

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

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

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

char* pfc::utf8_char_next ( char *  src  )  throw () [inline]

const char* pfc::utf8_char_next ( const char *  src  )  throw () [inline]

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

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

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

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

unsigned pfc::utf8_get_char ( const char *  src  ) 

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

static GUID pfc::xorGUID ( const GUID &  v1,
const GUID &  v2 
) [static]


Variable Documentation

const GUID pfc::guid_null


Generated on Thu Aug 28 21:16:05 2008 for foobar2000 SDK by  doxygen 1.5.5