cf Namespace Reference

corefoundation namespace More...

Namespaces
namespace	mutate

Classes
class	__string
	RAII CFString class. More...
class	_preference
	persistant storarage base class - do not use directly! use cf::preference More...
class	array
class	array<::CFArrayRef, cf_object_t >
class	array<::CFMutableArrayRef >
class	bundle
class	data
class	dictionary
	key value pair store More...
class	dictionary<::CFDictionaryRef, cf_object_t >
class	dictionary<::CFMutableDictionaryRef >
class	error
class	interface
class	interface<::IOCFPlugInInterface >
class	reference
class	runloop
class	stream
class	tree
	dx::key_value_tree<derived_t> contract (dxd/interface/dx_key_value_tree.h), implemented once for every CF-backed preference store (cf::_preference, sc::_preference, dx::coreaudio::server::_preference) - inherit from this (CRTP: class _preference: public cf::tree<_preference>) instead of reimplementing it. More...
class	type
class	type< bool >
class	type< char * >
class	type< const char * >
class	type< double >
class	type< float >
class	type< std::string >
class	type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==1 > >
class	type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==2 > >
class	type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==4 > >
class	type< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==8 > >
class	type<::CFTypeRef >
	opaque type serves as type::factory More...
class	url
class	uuid

Typedefs
using	bool_t = type<bool>
using	double_t = type<double>
using	float32 = type<float>
using	float64 = type<double>
using	float_t = type<float>
using	int16 = type<int16_t>
using	int32 = type<int32_t>
using	int64 = type<int64_t>
using	int8 = type<int8_t>
using	preference = dx::key_value_tree<_preference>
	preference store
using	string = type<const char*>
using	uint16 = type<uint16_t>
using	uint32 = type<uint32_t>
using	uint64 = type<uint64_t>
using	uint8 = type<uint8_t>

Functions
std::string	describe (dx::os_result result) noexcept
template<typename type_t>
constexpr bool	is_compatible ()
std::false_type	is_reference_test (...)
template<typename cf_object_t>
std::true_type	is_reference_test (const reference< cf_object_t > *)
std::ostream &	operator<< (std::ostream &, ::CFArrayRef)
std::ostream &	operator<< (std::ostream &, ::CFBooleanRef)
std::ostream &	operator<< (std::ostream &, ::CFDataRef)
std::ostream &	operator<< (std::ostream &, ::CFDictionaryRef)
std::ostream &	operator<< (std::ostream &, ::CFNumberRef)
std::ostream &	operator<< (std::ostream &, ::CFStringRef)
std::ostream &	operator<< (std::ostream &, ::CFTypeRef)
std::ostream &	operator<< (std::ostream &, ::CFURLRef)

Variables
template<typename type_t, typename cf_object_t = ::CFTypeRef>
constexpr bool	adopts_v
	foreign class whose CF conversion hands over a +1 (ownership rule above): adopted, not retained, on insertion
template<typename type_t>
constexpr bool	is_reference_v
	derived from any cf::reference<>: converts unretained, in contrast to a foreign class' +1 conversion

Detailed Description

corefoundation namespace

Typedef Documentation

bool_t

using cf::bool_t = type<bool>

double_t

using cf::double_t = type<double>

float32

using cf::float32 = type<float>

float64

using cf::float64 = type<double>

float_t

using cf::float_t = type<float>

int16

using cf::int16 = type<int16_t>

int32

using cf::int32 = type<int32_t>

int64

using cf::int64 = type<int64_t>

int8

using cf::int8 = type<int8_t>

preference

using cf::preference = dx::key_value_tree<_preference>

preference store

• usage:

  preference= value;
  preference[key]= value;
  preference[key1][key2]..[keyN]= value;
  value= preference;
  value= preference[key];
  value= preference[key](default_value);
  value= preference[key1][key2]..[keyN];
  value= preference[key1][key2]..[keyN](default_value);
   
  preference.erase();
  preference.erase(subkey);
  preference[key].erase();
  preference[key].erase(subkey);
  preference[key1][key2]..[keyN].erase();
  preference[key1][key2]..[keyN].erase(subkey);
   
  bool value= preference;

string

using cf::string = type<const char*>

uint16

using cf::uint16 = type<uint16_t>

uint32

using cf::uint32 = type<uint32_t>

uint64

using cf::uint64 = type<uint64_t>

uint8

using cf::uint8 = type<uint8_t>

Function Documentation

describe()

std::string cf::describe ( dx::os_result result )

inlinenoexcept

Here is the caller graph for this function:

is_compatible()

template<typename type_t>

bool cf::is_compatible ( )

constexpr

Here is the caller graph for this function:

is_reference_test() [1/2]

std::false_type cf::is_reference_test

(

...

)

Here is the call graph for this function:

is_reference_test() [2/2]

template<typename cf_object_t>

std::true_type cf::is_reference_test

(

const reference< cf_object_t > *

)

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [1/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFArrayRef ref )

inline

Here is the caller graph for this function:

operator<<() [2/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFBooleanRef ref )

inline

operator<<() [3/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFDataRef ref )

inline

operator<<() [4/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFDictionaryRef ref )

inline

Here is the call graph for this function:

operator<<() [5/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFNumberRef ref )

inline

operator<<() [6/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFStringRef ref )

inline

operator<<() [7/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFTypeRef ref )

inline

operator<<() [8/8]

std::ostream & cf::operator<< ( std::ostream & os, ::CFURLRef ref )

inline

Variable Documentation

adopts_v

template<typename type_t, typename cf_object_t = ::CFTypeRef>

bool cf::adopts_v

constexpr

Initial value:

                                 =
(std::is_class_v<type_t> || std::is_union_v<type_t>) && !is_reference_v<type_t> && std::is_convertible_v<const type_t&, cf_object_t>

foreign class whose CF conversion hands over a +1 (ownership rule above): adopted, not retained, on insertion

is_reference_v

template<typename type_t>

bool cf::is_reference_v

constexpr

Initial value:

                                    =
decltype(is_reference_test(std::declval<std::remove_reference_t<type_t>*>()))::value

derived from any cf::reference<>: converts unretained, in contrast to a foreign class' +1 conversion