Struct CFMutableDictionary 

#[repr(C)]
pub struct CFMutableDictionary<K: ?Sized = Opaque, V: ?Sized = Opaque> { /* private fields */ }

Available on crate feature CFDictionary only.

This is the type of a reference to mutable CFDictionarys.

See also Apple’s documentation

Implementations

impl<K: ?Sized, V: ?Sized> CFMutableDictionary<K, V>

Convenience creation methods.

pub fn empty() -> CFRetained<Self>

where K: Type + PartialEq + Hash, V: Type,

Create a new empty mutable dictionary.

pub fn with_capacity(capacity: usize) -> CFRetained<Self>

where K: Type + PartialEq + Hash, V: Type,

Create a new mutable dictionary with the given capacity.

impl<K: ?Sized, V: ?Sized> CFMutableDictionary<K, V>

Various mutation methods.

pub fn as_opaque(&self) -> &CFMutableDictionary

Convert to the opaque/untyped variant.

pub fn add(&self, key: &K, value: &V)

where K: Type + Sized + PartialEq + Hash, V: Type + Sized,

Add the key-value pair to the dictionary if no such key already exist.

pub fn set(&self, key: &K, value: &V)

where K: Type + Sized + PartialEq + Hash, V: Type + Sized,

Set the value of the key in the dictionary.

pub fn replace(&self, key: &K, value: &V)

where K: Type + Sized + PartialEq + Hash, V: Type + Sized,

Replace the value of the key in the dictionary.

pub fn remove(&self, key: &K)

where K: Type + Sized + PartialEq + Hash,

Remove the value from the dictionary associated with the key.

pub fn clear(&self)

Remove all keys and values from the dictionary.

impl CFMutableDictionary

pub unsafe fn new( allocator: Option<&CFAllocator>, capacity: CFIndex, key_call_backs: *const CFDictionaryKeyCallBacks, value_call_backs: *const CFDictionaryValueCallBacks, ) -> Option<CFRetained<CFMutableDictionary>>

Creates a new mutable dictionary.

Parameter allocator: The CFAllocator which should be used to allocate memory for the dictionary and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.

Parameter capacity: A hint about the number of values that will be held by the CFDictionary. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A dictionary’s actual capacity is only limited by address space and available memory constraints). If this parameter is negative, the behavior is undefined.

Parameter keyCallBacks: A pointer to a CFDictionaryKeyCallBacks structure initialized with the callbacks for the dictionary to use on each key in the dictionary. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple dictionary creations. If the version field of this callbacks structure is not one of the defined ones for CFDictionary, the behavior is undefined. The retain field may be NULL, in which case the CFDictionary will do nothing to add a retain to the keys of the contained values. The release field may be NULL, in which case the CFDictionary will do nothing to remove the dictionary’s retain (if any) on the keys when the dictionary is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the dictionary will create a simple description for a key. If the equal field is NULL, the dictionary will use pointer equality to test for equality of keys. If the hash field is NULL, a key will be converted from a pointer to an integer to compute the hash code. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFDictionaryKeyCallBacks callbacks structure, the behavior is undefined. If any of the keys put into the dictionary is not one understood by one of the callback functions the behavior when that callback function is used is undefined.

Parameter valueCallBacks: A pointer to a CFDictionaryValueCallBacks structure initialized with the callbacks for the dictionary to use on each value in the dictionary. The retain callback will be used within this function, for example, to retain all of the new values from the values C array. A copy of the contents of the callbacks structure is made, so that a pointer to a structure on the stack can be passed in, or can be reused for multiple dictionary creations. If the version field of this callbacks structure is not one of the defined ones for CFDictionary, the behavior is undefined. The retain field may be NULL, in which case the CFDictionary will do nothing to add a retain to values as they are put into the dictionary. The release field may be NULL, in which case the CFDictionary will do nothing to remove the dictionary’s retain (if any) on the values when the dictionary is destroyed or a key-value pair is removed. If the copyDescription field is NULL, the dictionary will create a simple description for a value. If the equal field is NULL, the dictionary will use pointer equality to test for equality of values. This callbacks parameter itself may be NULL, which is treated as if a valid structure of version 0 with all fields NULL had been passed in. Otherwise, if any of the fields are not valid pointers to functions of the correct type, or this parameter is not a valid pointer to a CFDictionaryValueCallBacks callbacks structure, the behavior is undefined. If any of the values put into the dictionary is not one understood by one of the callback functions the behavior when that callback function is used is undefined.

Returns: A reference to the new mutable CFDictionary.

pub unsafe fn new_copy( allocator: Option<&CFAllocator>, capacity: CFIndex, the_dict: Option<&CFDictionary>, ) -> Option<CFRetained<CFMutableDictionary>>

Creates a new mutable dictionary with the key-value pairs from the given dictionary.

Parameter allocator: The CFAllocator which should be used to allocate memory for the dictionary and its storage for values. This parameter may be NULL in which case the current default CFAllocator is used. If this reference is not a valid CFAllocator, the behavior is undefined.

Parameter capacity: A hint about the number of values that will be held by the CFDictionary. Pass 0 for no hint. The implementation may ignore this hint, or may use it to optimize various operations. A dictionary’s actual capacity is only limited by address space and available memory constraints). This parameter must be greater than or equal to the count of the dictionary which is to be copied, or the behavior is undefined. If this parameter is negative, the behavior is undefined.

Parameter theDict: The dictionary which is to be copied. The keys and values from the dictionary are copied as pointers into the new dictionary (that is, the values themselves are copied, not that which the values point to, if anything). However, the keys and values are also retained by the new dictionary using the retain function of the original dictionary. The count of the new dictionary will be the same as the given dictionary. The new dictionary uses the same callbacks as the dictionary to be copied. If this parameter is not a valid CFDictionary, the behavior is undefined.

Returns: A reference to the new mutable CFDictionary.

impl CFMutableDictionary

pub unsafe fn add_value( the_dict: Option<&CFMutableDictionary>, key: *const c_void, value: *const c_void, )

Adds the key-value pair to the dictionary if no such key already exists.

Parameter theDict: The dictionary to which the value is to be added. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.

Parameter key: The key of the value to add to the dictionary. The key is retained by the dictionary using the retain callback provided when the dictionary was created. If the key is not of the sort expected by the retain callback, the behavior is undefined. If a key which matches this key is already present in the dictionary, this function does nothing (“add if absent”).

Parameter value: The value to add to the dictionary. The value is retained by the dictionary using the retain callback provided when the dictionary was created. If the value is not of the sort expected by the retain callback, the behavior is undefined.

pub unsafe fn set_value( the_dict: Option<&CFMutableDictionary>, key: *const c_void, value: *const c_void, )

Sets the value of the key in the dictionary.

Parameter theDict: The dictionary to which the value is to be set. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.

Parameter key: The key of the value to set into the dictionary. If a key which matches this key is already present in the dictionary, only the value is changed (“add if absent, replace if present”). If no key matches the given key, the key-value pair is added to the dictionary. If added, the key is retained by the dictionary, using the retain callback provided when the dictionary was created. If the key is not of the sort expected by the key retain callback, the behavior is undefined.

Parameter value: The value to add to or replace into the dictionary. The value is retained by the dictionary using the retain callback provided when the dictionary was created, and the previous value if any is released. If the value is not of the sort expected by the retain or release callbacks, the behavior is undefined.

pub unsafe fn replace_value( the_dict: Option<&CFMutableDictionary>, key: *const c_void, value: *const c_void, )

Replaces the value of the key in the dictionary.

Parameter theDict: The dictionary to which the value is to be replaced. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.

Parameter key: The key of the value to replace in the dictionary. If a key which matches this key is present in the dictionary, the value is changed to the given value, otherwise this function does nothing (“replace if present”).

Parameter value: The value to replace into the dictionary. The value is retained by the dictionary using the retain callback provided when the dictionary was created, and the previous value is released. If the value is not of the sort expected by the retain or release callbacks, the behavior is undefined.

pub unsafe fn remove_value( the_dict: Option<&CFMutableDictionary>, key: *const c_void, )

Removes the value of the key from the dictionary.

Parameter theDict: The dictionary from which the value is to be removed. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.

Parameter key: The key of the value to remove from the dictionary. If a key which matches this key is present in the dictionary, the key-value pair is removed from the dictionary, otherwise this function does nothing (“remove if present”).

pub fn remove_all_values(the_dict: Option<&CFMutableDictionary>)

Removes all the values from the dictionary, making it empty.

Parameter theDict: The dictionary from which all of the values are to be removed. If this parameter is not a valid mutable CFDictionary, the behavior is undefined.

Methods from Deref<Target = CFDictionary<K, V>>

pub unsafe fn get_unchecked(&self, key: &K) -> Option<&V>

where K: Type + Sized, V: Type + Sized,

Get a direct reference to one of the dictionary’s values.

Consider using the get method instead, unless you’re seeing performance issues from the retaining.

Safety

The dictionary must not be mutated while the returned reference is live.

pub unsafe fn to_vecs_unchecked(&self) -> (Vec<&K>, Vec<&V>)

where K: Type, V: Type,

Available on crate feature alloc only.

A vector containing direct references to the dictionary’s keys and values.

Consider using the to_vecs method instead, unless you’re seeing performance issues from the retaining.

Safety

The array must not be mutated while the returned references are alive.

pub fn as_opaque(&self) -> &CFDictionary

Convert to the opaque/untyped variant.

pub fn len(&self) -> usize

The amount of elements in the dictionary.

pub fn is_empty(&self) -> bool

Whether the dictionary is empty or not.

pub fn get(&self, key: &K) -> Option<CFRetained<V>>

where K: Type + Sized + PartialEq + Hash, V: Type + Sized,

Retrieve the object at the given index.

Returns None if the index was out of bounds.

pub fn to_vecs(&self) -> (Vec<CFRetained<K>>, Vec<CFRetained<V>>)

where K: Type + Sized, V: Type + Sized,

Available on crate feature alloc only.

Two vectors containing respectively the dictionary’s keys and values.

pub fn contains_key(&self, key: &K) -> bool

where K: Type + Sized + PartialEq + Hash,

Whether the key is in the dictionary.

pub fn contains_value(&self, value: &V) -> bool

where V: Type + Sized + PartialEq,

Whether the value can be found anywhere in the dictionary.

pub fn count(self: &CFDictionary) -> CFIndex

Returns the number of values currently in the dictionary.

Parameter theDict: The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.

Returns: The number of values in the dictionary.

pub unsafe fn count_of_key(self: &CFDictionary, key: *const c_void) -> CFIndex

Counts the number of times the given key occurs in the dictionary.

Parameter theDict: The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter key: The key for which to find matches in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.

Returns: Returns 1 if a matching key is used by the dictionary, 0 otherwise.

pub unsafe fn count_of_value( self: &CFDictionary, value: *const c_void, ) -> CFIndex

Counts the number of times the given value occurs in the dictionary.

Parameter theDict: The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter value: The value for which to find matches in the dictionary. The equal() callback provided when the dictionary was created is used to compare. If the equal() value callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the dictionary, are not understood by the equal() callback, the behavior is undefined.

Returns: The number of times the given value occurs in the dictionary.

pub unsafe fn contains_ptr_key(self: &CFDictionary, key: *const c_void) -> bool

Reports whether or not the key is in the dictionary.

Parameter theDict: The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter key: The key for which to find matches in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.

Returns: true, if the key is in the dictionary, otherwise false.

pub unsafe fn contains_ptr_value( self: &CFDictionary, value: *const c_void, ) -> bool

Reports whether or not the value is in the dictionary.

Parameter theDict: The dictionary to be searched. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter value: The value for which to find matches in the dictionary. The equal() callback provided when the dictionary was created is used to compare. If the equal() callback was NULL, pointer equality (in C, ==) is used. If value, or any of the values in the dictionary, are not understood by the equal() callback, the behavior is undefined.

Returns: true, if the value is in the dictionary, otherwise false.

pub unsafe fn value(self: &CFDictionary, key: *const c_void) -> *const c_void

Retrieves the value associated with the given key.

Parameter theDict: The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter key: The key for which to find a match in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.

Returns: The value with the given key in the dictionary, or NULL if no key-value pair with a matching key exists. Since NULL can be a valid value in some dictionaries, the function CFDictionaryGetValueIfPresent() must be used to distinguish NULL-no-found from NULL-is-the-value.

pub unsafe fn value_if_present( self: &CFDictionary, key: *const c_void, value: *mut *const c_void, ) -> bool

Retrieves the value associated with the given key.

Parameter theDict: The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter key: The key for which to find a match in the dictionary. The hash() and equal() key callbacks provided when the dictionary was created are used to compare. If the hash() key callback was NULL, the key is treated as a pointer and converted to an integer. If the equal() key callback was NULL, pointer equality (in C, ==) is used. If key, or any of the keys in the dictionary, are not understood by the equal() callback, the behavior is undefined.

Parameter value: A pointer to memory which should be filled with the pointer-sized value if a matching key is found. If no key match is found, the contents of the storage pointed to by this parameter are undefined. This parameter may be NULL, in which case the value from the dictionary is not returned (but the return value of this function still indicates whether or not the key-value pair was present).

Returns: true, if a matching key was found, false otherwise.

pub unsafe fn keys_and_values( self: &CFDictionary, keys: *mut *const c_void, values: *mut *const c_void, )

Fills the two buffers with the keys and values from the dictionary.

Parameter theDict: The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter keys: A C array of pointer-sized values to be filled with keys from the dictionary. The keys and values C arrays are parallel to each other (that is, the items at the same indices form a key-value pair from the dictionary). This parameter may be NULL if the keys are not desired. If this parameter is not a valid pointer to a C array of at least CFDictionaryGetCount() pointers, or NULL, the behavior is undefined.

Parameter values: A C array of pointer-sized values to be filled with values from the dictionary. The keys and values C arrays are parallel to each other (that is, the items at the same indices form a key-value pair from the dictionary). This parameter may be NULL if the values are not desired. If this parameter is not a valid pointer to a C array of at least CFDictionaryGetCount() pointers, or NULL, the behavior is undefined.

pub unsafe fn apply_function( self: &CFDictionary, applier: CFDictionaryApplierFunction, context: *mut c_void, )

Calls a function once for each value in the dictionary.

Parameter theDict: The dictionary to be queried. If this parameter is not a valid CFDictionary, the behavior is undefined.

Parameter applier: The callback function to call once for each value in the dictionary. If this parameter is not a pointer to a function of the correct prototype, the behavior is undefined. If there are keys or values which the applier function does not expect or cannot properly apply to, the behavior is undefined.

Parameter context: A pointer-sized user-defined value, which is passed as the third parameter to the applier function, but is otherwise unused by this function. If the context is not what is expected by the applier function, the behavior is undefined.

Methods from Deref<Target = CFType>

pub fn downcast_ref<T: ConcreteType>(&self) -> Option<&T>

Attempt to downcast the type to that of type T.

This is the reference-variant. Use CFRetained::downcast if you want to convert a retained type. See also ConcreteType for more details on which types support being converted to.

pub fn retain_count(&self) -> usize

Get the reference count of the object.

This function may be useful for debugging. You normally do not use this function otherwise.

Beware that some things (like CFNumbers, small CFStrings etc.) may not have a normal retain count for optimization purposes, and can return usize::MAX in that case.

Trait Implementations

impl<K: ?Sized, V: ?Sized> AsRef<AnyObject> for CFMutableDictionary<K, V>

fn as_ref(&self) -> &AnyObject

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: ?Sized, V: ?Sized> AsRef<CFDictionary<K, V>> for CFMutableDictionary<K, V>

fn as_ref(&self) -> &CFDictionary<K, V>

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: ?Sized, V: ?Sized> AsRef<CFMutableDictionary<K, V>> for CFMutableDictionary<K, V>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: ?Sized + Type, V: ?Sized + Type> AsRef<CFMutableDictionary> for CFMutableDictionary<K, V>

fn as_ref(&self) -> &CFMutableDictionary

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: ?Sized, V: ?Sized> AsRef<CFType> for CFMutableDictionary<K, V>

fn as_ref(&self) -> &CFType

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: ?Sized, V: ?Sized> Borrow<AnyObject> for CFMutableDictionary<K, V>

fn borrow(&self) -> &AnyObject

Immutably borrows from an owned value.

impl<K: ?Sized, V: ?Sized> Borrow<CFDictionary<K, V>> for CFMutableDictionary<K, V>

fn borrow(&self) -> &CFDictionary<K, V>

Immutably borrows from an owned value.

impl<K: ?Sized + Type, V: ?Sized + Type> Borrow<CFMutableDictionary> for CFMutableDictionary<K, V>

fn borrow(&self) -> &CFMutableDictionary

Immutably borrows from an owned value.

impl<K: ?Sized, V: ?Sized> Borrow<CFType> for CFMutableDictionary<K, V>

fn borrow(&self) -> &CFType

Immutably borrows from an owned value.

impl<K: ?Sized, V: ?Sized> Debug for CFMutableDictionary<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K: ?Sized, V: ?Sized> Deref for CFMutableDictionary<K, V>

type Target = CFDictionary<K, V>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K: ?Sized, V: ?Sized> Hash for CFMutableDictionary<K, V>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<K: ?Sized, V: ?Sized> Message for CFMutableDictionary<K, V>

fn retain(&self) -> Retained<Self>

where Self: Sized,

Increment the reference count of the receiver.

impl<K: ?Sized, V: ?Sized> PartialEq for CFMutableDictionary<K, V>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: ?Sized, V: ?Sized> RefEncode for CFMutableDictionary<K, V>

const ENCODING_REF: Encoding

The Objective-C type-encoding for a reference of this type.

impl<K: ?Sized, V: ?Sized> Type for CFMutableDictionary<K, V>

fn retain(&self) -> CFRetained<Self>

where Self: Sized,

Increment the reference count of the receiver.

fn as_concrete_TypeRef(&self) -> &Self

👎Deprecated: this is redundant

Helper for easier transition from the core-foundation crate.

unsafe fn wrap_under_get_rule(ptr: *const Self) -> CFRetained<Self>

where Self: Sized,

👎Deprecated: use CFRetained::retain

Helper for easier transition from the core-foundation crate.

fn as_CFTypeRef(&self) -> &CFType

where Self: AsRef<CFType>,

👎Deprecated: this is redundant (CF types deref to CFType)

Helper for easier transition from the core-foundation crate.

unsafe fn wrap_under_create_rule(ptr: *const Self) -> CFRetained<Self>

where Self: Sized,

👎Deprecated: use CFRetained::from_raw

Helper for easier transition from the core-foundation crate.

impl<K: ?Sized, V: ?Sized> Eq for CFMutableDictionary<K, V>