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

Go to the source code of this file.

Data Structures

class  pfc::__exception_with_message_t< t_base >
 
class  pfc::__list_to_array_enumerator< t_array >
 
class  pfc::assert_byte_type< t_type >
 
class  pfc::assert_byte_type< char >
 
class  pfc::assert_byte_type< signed char >
 
class  pfc::assert_byte_type< unsigned char >
 
class  pfc::assert_same_type< p_type1, p_type2 >
 
class  pfc::assert_same_type< p_type, p_type >
 
class  pfc::comparator_default
 
class  pfc::comparator_dual< t_primary, t_secondary >
 
class  pfc::comparator_memcmp
 
class  pfc::comparator_pointer< t_comparator >
 
class  pfc::enumerator_add_item< t_receiver >
 
class  pfc::incrementScope< t_val >
 
class  pfc::is_same_type< p_type1, p_type2 >
 
class  pfc::is_same_type< p_type, p_type >
 
class  pfc::static_assert_t< val >
 
class  pfc::static_assert_t< true >
 

Namespaces

 pfc
 

Typedefs

typedef std::exception pfc::exception
 

Functions

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)
 
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)
 
template<typename t_type >
t_type * pfc::__unsafe__in_place_constructor_array_t (t_type *p_items, t_size p_count)
 
template<typename t_type , typename t_copy >
void pfc::__unsafe__in_place_constructor_copy_t (t_type &p_item, const t_copy &p_copyfrom)
 
template<typename t_type >
void pfc::__unsafe__in_place_constructor_t (t_type &p_item)
 
template<typename t_type >
void pfc::__unsafe__in_place_destructor_array_t (t_type *p_items, t_size p_count) throw ()
 
template<typename t_type >
void pfc::__unsafe__in_place_destructor_t (t_type &p_item) throw ()
 
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)
 
template<typename t_type >
void pfc::__unsafe__memcpy_t (t_type *p_dst, const t_type *p_src, t_size p_count)
 
template<t_size p_size>
void pfc::__unsafe__swap_raw_t (void *p_object1, void *p_object2)
 
template<typename T >
T pfc::abs_t (T item)
 
template<typename t_int >
void pfc::acc_unsigned_clipped (t_int &v1, t_int v2)
 
template<typename t_acc , typename t_add >
void pfc::accumulate_guarded (t_acc &p_acc, const t_add &p_add)
 
template<typename t_int >
t_int pfc::add_unsigned_clipped (t_int v1, t_int v2)
 
template<typename t_array , typename T >
t_size pfc::append_swap_t (t_array &p_array, T &p_item)
 
template<typename t_array , typename T >
t_size pfc::append_t (t_array &p_array, const T &p_item)
 
template<typename t_array , typename t_item >
static bool pfc::array_isFirst (const t_array &arr, const t_item &item)
 
template<typename t_array , typename t_item >
static bool pfc::array_isLast (const t_array &arr, const t_item &item)
 
template<typename t_array >
void pfc::array_rangecheck_t (const t_array &p_array, t_size p_index)
 
template<typename t_array >
void pfc::array_rangecheck_t (const t_array &p_array, t_size p_from, t_size p_to)
 
template<typename t_array >
t_size pfc::array_size_t (const t_array &p_array)
 
template<typename t_item , t_size p_width>
t_size pfc::array_size_t (const t_item(&p_array)[p_width])
 
template<typename t_type >
void pfc::assert_raw_type ()
 
void pfc::bug_check_assert (bool p_condition, const char *p_msg)
 
void pfc::bug_check_assert (bool p_condition)
 
template<typename T >
T pfc::clip_t (const T &p_item, const T &p_min, const T &p_max)
 
template<typename T >
Tpfc::clone_t (T *ptr)
 
template<typename t_item1 , typename t_item2 >
int pfc::compare_t (const t_item1 &p_item1, const t_item2 &p_item2)
 
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)
 
template<typename t_to , typename t_from >
void pfc::copy_array_t (t_to &p_to, const t_from &p_from)
 
template<typename t_receiver , typename t_giver >
void pfc::copy_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
 
unsigned pfc::countBits32 (uint32_t i)
 
template<typename T >
void pfc::delete_array_t (T *ptr)
 
template<typename T >
void pfc::delete_t (T *ptr)
 
template<typename t_ret , typename t_param >
t_ret pfc::downcast_guarded (const t_param &p_param)
 
template<typename t_exception , typename t_ret , typename t_param >
t_ret pfc::downcast_guarded_ex (const t_param &p_param)
 
void pfc::dynamic_assert (bool p_condition, const char *p_msg)
 
void pfc::dynamic_assert (bool p_condition)
 
template<typename T >
const Tpfc::empty_string_t ()
 
template<>
const char * pfc::empty_string_t< char > ()
 
template<>
const wchar_t * pfc::empty_string_t< wchar_t > ()
 
template<typename t_array , typename t_value >
void pfc::fill_array_t (t_array &p_array, const t_value &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)
 
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)
 
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)
 
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)
 
template<typename t_ret >
t_ret pfc::implicit_cast (t_ret val)
 
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)
 
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)
 
template<typename t_array , typename T >
t_size pfc::insert_swap_t (t_array &p_array, T &p_item, t_size 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)
 
template<typename t_array >
t_size pfc::insert_uninitialized_t (t_array &p_array, t_size p_index)
 
template<t_size p_size_pow2>
bool pfc::is_ptr_aligned_t (const void *p_ptr)
 
template<typename t_list , typename t_array >
void pfc::list_to_array (t_array &p_array, const t_list &p_list)
 
bool pfc::lxor (bool p_val1, bool p_val2)
 
template<typename t_val >
void pfc::max_acc (t_val &p_acc, const t_val &p_val)
 
template<typename T >
T pfc::max_t (const T &item1, const T &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)
 
template<typename t_src , typename t_dst >
void pfc::memcpy_t (t_dst *p_dst, const t_src *p_src, t_size p_count)
 
template<typename T >
void pfc::memmove_t (T *p_dst, const T *p_src, t_size p_count)
 
template<typename T >
void pfc::memset_null_t (T *p_buffer, t_size p_count)
 
template<typename T >
void pfc::memset_null_t (T &p_buffer)
 
template<typename T , typename t_val >
void pfc::memset_t (T *p_buffer, const t_val &p_val, t_size p_count)
 
template<typename T , typename t_val >
void pfc::memset_t (T &p_buffer, const t_val &p_val)
 
static void pfc::memxor (void *target, const void *source1, const void *source2, t_size size)
 
template<typename TVal >
void pfc::memxor_t (TVal *out, const TVal *s1, const TVal *s2, t_size count)
 
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)
 
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)
 
template<typename t_val >
void pfc::min_acc (t_val &p_acc, const t_val &p_val)
 
template<typename T >
T pfc::min_t (const T &item1, const T &item2)
 
template<typename T >
void pfc::move_t (T &p_item1, T &p_item2)
 
template<typename t_exception , typename t_int >
t_int pfc::mul_safe_t (t_int p_val1, t_int p_val2)
 
template<typename t_int >
t_int pfc::multiply_guarded (t_int v1, t_int v2)
 
template<typename T >
Tpfc::new_ptr_check_t (T *p_ptr)
 
template<typename t_receiver , typename t_giver >
void pfc::overwrite_list_enumerated (t_receiver &p_receiver, const t_giver &p_giver)
 
 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")
 
t_uint64 pfc::pow_int (t_uint64 base, t_uint64 exp)
 
template<typename t_array >
t_size pfc::remove_mask_t (t_array &p_array, const bit_array &p_mask)
 
template<typename t_type >
t_type pfc::replace_null_t (t_type &p_var)
 
template<typename t_type , typename t_newval >
t_type pfc::replace_t (t_type &p_var, const t_newval &p_newval)
 
t_int32 pfc::rint32 (double p_val)
 
t_int64 pfc::rint64 (double p_val)
 
template<typename t_ret , typename t_param >
t_ret * pfc::safe_ptr_cast (t_param *p_param)
 
template<typename T >
int pfc::sgn_t (const T &p_val)
 
template<typename T >
T pfc::sqr_t (T item)
 
template<typename t_char >
t_size pfc::strlen_t (const t_char *p_string, t_size p_length=~0)
 
template<typename t_int >
t_int pfc::sub_unsigned_clipped (t_int v1, t_int v2)
 
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)
 
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)
 
template<typename T >
void pfc::swap_multi_t (T *p_buffer1, T *p_buffer2, t_size p_size)
 
template<typename T , t_size p_size>
void pfc::swap_multi_t (T *p_buffer1, T *p_buffer2)
 
template<typename T >
void pfc::swap_t (T &p_item1, T &p_item2)
 
template<typename t_exception >
PFC_NORETURN void pfc::throw_exception_with_message (const char *p_message)
 

Data Structure Documentation

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