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 >
	a ::CFArray read: its elements as a plain vector (container, unretained) or as cf::type values (dx_container), and a range-for over them More...
class	array<::CFMutableArrayRef >
	an array being built: add() appends, and the result converts to what an API asks for More...
class	bundle
	a bundle by identifier, or the running one: its URL, its resources and its Info.plist as a dictionary More...
class	data
	a byte blob: made from a string, a buffer or a file, compared and copied back out - what a certificate's DER, a descriptor or a property's raw bytes travel in More...
class	dictionary
	key value pair store More...
class	dictionary<::CFDictionaryRef, cf_object_t >
	a ::CFDictionary read: operator [] names an entry, which converts to what the caller asks for, and a range-for walks key and value pairs. An entry hands out a retained value (cf::reference's ownership rule) More...
class	dictionary<::CFMutableDictionaryRef >
	a dictionary being built: set() chains one entry after another, which is what the desc's CF serialization expands into More...
class	error
	a ::CFError, in both directions: made from an OSStatus to name it, or taken from an API that hands one out (operator ::CFErrorRef*() is the out parameter). cf::describe is what dx::exception prints for a macOS result More...
class	interface
	a COM style IOKit plugin interface: QueryInterface on the plugin (or on an io_object_t, which is opened as a plugin first) and the release at the end of the object's life - every IOUSBLib and IOCFPlugIn interface is reached through one More...
class	interface<::IOCFPlugInInterface >
class	reference
class	runloop
	a run loop on a thread of its own: sources are added with += and removed with -=, and the object's construction waits until that loop is up, so a source may be attached right away. Every dxd entity that takes IOKit or CF notifications owns one More...
class	stream
	a file open for reading, closed with the object; its offset is what a parse error is reported at More...
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 >
	a boolean is no ::CFNumber but one of the two ::kCFBoolean singletons, so this one carries no reference of its own More...
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
	a file system path or a bundle resource as a ::CFURL, converting back to a path, a string and a read stream More...
class	uuid
	a UUID, generated or read from its string or bytes - dx::guid on macOS More...

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