objc2_core_foundation/generated/

CFArray.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::cell::UnsafeCell;
use core::ffi::*;
use core::marker::{PhantomData, PhantomPinned};
use core::ptr::NonNull;
#[cfg(feature = "objc2")]
use objc2::__framework_prelude::*;

use crate::*;

/// Structure containing the callbacks of a CFArray.
/// Field: version The version number of the structure type being passed
/// in as a parameter to the CFArray creation functions. This
/// structure is version 0.
/// Field: retain The callback used to add a retain for the array on
/// values as they are put into the array. This callback returns
/// the value to store in the array, which is usually the value
/// parameter passed to this callback, but may be a different
/// value if a different value should be stored in the array.
/// The array's allocator is passed as the first argument.
/// Field: release The callback used to remove a retain previously added
/// for the array from values as they are removed from the
/// array. The array's allocator is passed as the first
/// argument.
/// Field: copyDescription The callback used to create a descriptive
/// string representation of each value in the array. This is
/// used by the CFCopyDescription() function.
/// Field: equal The callback used to compare values in the array for
/// equality for some operations.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarrayretaincallback?language=objc)
pub type CFArrayRetainCallBack =
    Option<unsafe extern "C-unwind" fn(*const CFAllocator, *const c_void) -> *const c_void>;

/// [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarrayreleasecallback?language=objc)
pub type CFArrayReleaseCallBack =
    Option<unsafe extern "C-unwind" fn(*const CFAllocator, *const c_void)>;

/// [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarraycopydescriptioncallback?language=objc)
pub type CFArrayCopyDescriptionCallBack =
    Option<unsafe extern "C-unwind" fn(*const c_void) -> *const CFString>;

/// [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarrayequalcallback?language=objc)
pub type CFArrayEqualCallBack =
    Option<unsafe extern "C-unwind" fn(*const c_void, *const c_void) -> Boolean>;

/// [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarraycallbacks?language=objc)
#[repr(C)]
#[allow(unpredictable_function_pointer_comparisons)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CFArrayCallBacks {
    pub version: CFIndex,
    pub retain: CFArrayRetainCallBack,
    pub release: CFArrayReleaseCallBack,
    pub copyDescription: CFArrayCopyDescriptionCallBack,
    pub equal: CFArrayEqualCallBack,
}

#[cfg(feature = "objc2")]
unsafe impl Encode for CFArrayCallBacks {
    const ENCODING: Encoding = Encoding::Struct(
        "?",
        &[
            <CFIndex>::ENCODING,
            <CFArrayRetainCallBack>::ENCODING,
            <CFArrayReleaseCallBack>::ENCODING,
            <CFArrayCopyDescriptionCallBack>::ENCODING,
            <CFArrayEqualCallBack>::ENCODING,
        ],
    );
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for CFArrayCallBacks {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern "C" {
    /// Predefined CFArrayCallBacks structure containing a set of callbacks
    /// appropriate for use when the values in a CFArray are all CFTypes.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/kcftypearraycallbacks?language=objc)
    pub static kCFTypeArrayCallBacks: CFArrayCallBacks;
}

/// Type of the callback function used by the apply functions of
/// CFArrays.
///
/// Parameter `value`: The current value from the array.
///
/// Parameter `context`: The user-defined context parameter given to the apply
/// function.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarrayapplierfunction?language=objc)
pub type CFArrayApplierFunction = Option<unsafe extern "C-unwind" fn(*const c_void, *mut c_void)>;

/// This is the type of a reference to immutable CFArrays.
///
/// This is toll-free bridged with `NSArray`.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfarray?language=objc)
#[doc(alias = "CFArrayRef")]
#[repr(C)]
pub struct CFArray<T: ?Sized = Opaque> {
    inner: [u8; 0],
    _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
    _generics: PhantomData<(*mut T,)>,
}

cf_type!(
    unsafe impl<T: ?Sized> CFArray<T> {}
);
#[cfg(feature = "objc2")]
cf_objc2_type!(
    unsafe impl<T: ?Sized> RefEncode<"__CFArray"> for CFArray<T> {}
);

impl<T: ?Sized> CFArray<T> {
    /// Unchecked conversion of the generic parameter.
    ///
    /// # Safety
    ///
    /// The generic must be valid to reinterpret as the given type.
    #[inline]
    pub unsafe fn cast_unchecked<NewT: ?Sized>(&self) -> &CFArray<NewT> {
        unsafe { &*((self as *const Self).cast()) }
    }

    /// Convert to the opaque/untyped variant.
    #[inline]
    pub fn as_opaque(&self) -> &CFArray {
        unsafe { self.cast_unchecked() }
    }
}

/// This is the type of a reference to mutable CFArrays.
///
/// This is toll-free bridged with `NSMutableArray`.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfmutablearray?language=objc)
#[doc(alias = "CFMutableArrayRef")]
#[repr(C)]
pub struct CFMutableArray<T: ?Sized = Opaque> {
    inner: [u8; 0],
    _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
    _generics: PhantomData<(*mut T,)>,
}

cf_type!(
    unsafe impl<T: ?Sized> CFMutableArray<T>: CFArray<T> {}
);
#[cfg(feature = "objc2")]
cf_objc2_type!(
    unsafe impl<T: ?Sized> RefEncode<"__CFArray"> for CFMutableArray<T> {}
);

impl<T: ?Sized> CFMutableArray<T> {
    /// Unchecked conversion of the generic parameter.
    ///
    /// # Safety
    ///
    /// The generic must be valid to reinterpret as the given type.
    #[inline]
    pub unsafe fn cast_unchecked<NewT: ?Sized>(&self) -> &CFMutableArray<NewT> {
        unsafe { &*((self as *const Self).cast()) }
    }

    /// Convert to the opaque/untyped variant.
    #[inline]
    pub fn as_opaque(&self) -> &CFMutableArray {
        unsafe { self.cast_unchecked() }
    }
}

unsafe impl ConcreteType for CFArray {
    /// Returns the type identifier of all CFArray instances.
    #[doc(alias = "CFArrayGetTypeID")]
    #[inline]
    fn type_id() -> CFTypeID {
        extern "C-unwind" {
            fn CFArrayGetTypeID() -> CFTypeID;
        }
        unsafe { CFArrayGetTypeID() }
    }
}

impl CFArray {
    /// Creates a new immutable array with the given values.
    ///
    /// Parameter `allocator`: The CFAllocator which should be used to allocate
    /// memory for the array 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 `values`: A C array of the pointer-sized values to be in the
    /// array. The values in the array are ordered in the same order
    /// in which they appear in this C array. This parameter may be
    /// NULL if the numValues parameter is 0. This C array is not
    /// changed or freed by this function. If this parameter is not
    /// a valid pointer to a C array of at least numValues pointers,
    /// the behavior is undefined.
    ///
    /// Parameter `numValues`: The number of values to copy from the values C
    /// array into the CFArray. This number will be the count of the
    /// array.
    /// If this parameter is negative, or greater than the number of
    /// values actually in the value's C array, the behavior is
    /// undefined.
    ///
    /// Parameter `callBacks`: A pointer to a CFArrayCallBacks structure
    /// initialized with the callbacks for the array to use on each
    /// value in the array. 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 array creations. If the version field of this
    /// callbacks structure is not one of the defined ones for
    /// CFArray, the behavior is undefined. The retain field may be
    /// NULL, in which case the CFArray will do nothing to add a
    /// retain to the contained values for the array. The release
    /// field may be NULL, in which case the CFArray will do nothing
    /// to remove the array's retain (if any) on the values when the
    /// array is destroyed. If the copyDescription field is NULL,
    /// the array will create a simple description for the value. If
    /// the equal field is NULL, the array 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  CFArrayCallBacks callbacks structure,
    /// the behavior is undefined. If any of the values put into the
    /// array 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 immutable CFArray.
    ///
    /// # Safety
    ///
    /// - `allocator` might not allow `None`.
    /// - `values` must be a valid pointer.
    /// - `call_backs` must be a valid pointer.
    #[doc(alias = "CFArrayCreate")]
    #[inline]
    pub unsafe fn new(
        allocator: Option<&CFAllocator>,
        values: *mut *const c_void,
        num_values: CFIndex,
        call_backs: *const CFArrayCallBacks,
    ) -> Option<CFRetained<CFArray>> {
        extern "C-unwind" {
            fn CFArrayCreate(
                allocator: Option<&CFAllocator>,
                values: *mut *const c_void,
                num_values: CFIndex,
                call_backs: *const CFArrayCallBacks,
            ) -> Option<NonNull<CFArray>>;
        }
        let ret = unsafe { CFArrayCreate(allocator, values, num_values, call_backs) };
        ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
    }

    /// Creates a new immutable array with the values from the given array.
    ///
    /// Parameter `allocator`: The CFAllocator which should be used to allocate
    /// memory for the array 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 `theArray`: The array which is to be copied. The values from the
    /// array are copied as pointers into the new array (that is,
    /// the values themselves are copied, not that which the values
    /// point to, if anything). However, the values are also
    /// retained by the new array. The count of the new array will
    /// be the same as the given array. The new array uses the same
    /// callbacks as the array to be copied. If this parameter is
    /// not a valid CFArray, the behavior is undefined.
    ///
    /// Returns: A reference to the new immutable CFArray.
    ///
    /// # Safety
    ///
    /// - `allocator` might not allow `None`.
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    #[doc(alias = "CFArrayCreateCopy")]
    #[inline]
    pub unsafe fn new_copy(
        allocator: Option<&CFAllocator>,
        the_array: Option<&CFArray>,
    ) -> Option<CFRetained<CFArray>> {
        extern "C-unwind" {
            fn CFArrayCreateCopy(
                allocator: Option<&CFAllocator>,
                the_array: Option<&CFArray>,
            ) -> Option<NonNull<CFArray>>;
        }
        let ret = unsafe { CFArrayCreateCopy(allocator, the_array) };
        ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
    }
}

impl CFMutableArray {
    /// Creates a new empty mutable array.
    ///
    /// Parameter `allocator`: The CFAllocator which should be used to allocate
    /// memory for the array 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 CFArray. Pass 0 for no hint. The implementation may
    /// ignore this hint, or may use it to optimize various
    /// operations. An array's actual capacity is only limited by
    /// address space and available memory constraints). If this
    /// parameter is negative, the behavior is undefined.
    ///
    /// Parameter `callBacks`: A pointer to a CFArrayCallBacks structure
    /// initialized with the callbacks for the array to use on each
    /// value in the 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 array creations. If the version field of this
    /// callbacks structure is not one of the defined ones for
    /// CFArray, the behavior is undefined. The retain field may be
    /// NULL, in which case the CFArray will do nothing to add a
    /// retain to the contained values for the array. The release
    /// field may be NULL, in which case the CFArray will do nothing
    /// to remove the array's retain (if any) on the values when the
    /// array is destroyed. If the copyDescription field is NULL,
    /// the array will create a simple description for the value. If
    /// the equal field is NULL, the array 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  CFArrayCallBacks callbacks structure,
    /// the behavior is undefined. If any of the values put into the
    /// array 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 CFArray.
    ///
    /// # Safety
    ///
    /// - `allocator` might not allow `None`.
    /// - `call_backs` must be a valid pointer.
    /// - The returned generic must be of the correct type.
    #[doc(alias = "CFArrayCreateMutable")]
    #[inline]
    pub unsafe fn new(
        allocator: Option<&CFAllocator>,
        capacity: CFIndex,
        call_backs: *const CFArrayCallBacks,
    ) -> Option<CFRetained<CFMutableArray>> {
        extern "C-unwind" {
            fn CFArrayCreateMutable(
                allocator: Option<&CFAllocator>,
                capacity: CFIndex,
                call_backs: *const CFArrayCallBacks,
            ) -> Option<NonNull<CFMutableArray>>;
        }
        let ret = unsafe { CFArrayCreateMutable(allocator, capacity, call_backs) };
        ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
    }

    /// Creates a new mutable array with the values from the given array.
    ///
    /// Parameter `allocator`: The CFAllocator which should be used to allocate
    /// memory for the array 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 CFArray. Pass 0 for no hint. The implementation may
    /// ignore this hint, or may use it to optimize various
    /// operations. An array'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 array which is to be copied, or the
    /// behavior is undefined. If this parameter is negative, the
    /// behavior is undefined.
    ///
    /// Parameter `theArray`: The array which is to be copied. The values from the
    /// array are copied as pointers into the new array (that is,
    /// the values themselves are copied, not that which the values
    /// point to, if anything). However, the values are also
    /// retained by the new array. The count of the new array will
    /// be the same as the given array. The new array uses the same
    /// callbacks as the array to be copied. If this parameter is
    /// not a valid CFArray, the behavior is undefined.
    ///
    /// Returns: A reference to the new mutable CFArray.
    ///
    /// # Safety
    ///
    /// - `allocator` might not allow `None`.
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - The returned generic must be of the correct type.
    #[doc(alias = "CFArrayCreateMutableCopy")]
    #[inline]
    pub unsafe fn new_copy(
        allocator: Option<&CFAllocator>,
        capacity: CFIndex,
        the_array: Option<&CFArray>,
    ) -> Option<CFRetained<CFMutableArray>> {
        extern "C-unwind" {
            fn CFArrayCreateMutableCopy(
                allocator: Option<&CFAllocator>,
                capacity: CFIndex,
                the_array: Option<&CFArray>,
            ) -> Option<NonNull<CFMutableArray>>;
        }
        let ret = unsafe { CFArrayCreateMutableCopy(allocator, capacity, the_array) };
        ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
    }
}

impl CFArray {
    /// Returns the number of values currently in the array.
    ///
    /// Parameter `theArray`: The array to be queried. If this parameter is not a valid
    /// CFArray, the behavior is undefined.
    ///
    /// Returns: The number of values in the array.
    #[doc(alias = "CFArrayGetCount")]
    #[inline]
    pub fn count(&self) -> CFIndex {
        extern "C-unwind" {
            fn CFArrayGetCount(the_array: &CFArray) -> CFIndex;
        }
        unsafe { CFArrayGetCount(self) }
    }

    /// Counts the number of times the given value occurs in the array.
    ///
    /// Parameter `theArray`: The array to be searched. If this parameter is not a
    /// valid CFArray, the behavior is undefined.
    ///
    /// Parameter `range`: The range within the array to search. If the range
    /// location or end point (defined by the location plus length
    /// minus 1) is outside the index space of the array (0 to
    /// N-1 inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0).
    ///
    /// Parameter `value`: The value for which to find matches in the array. The
    /// equal() callback provided when the array 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 array, are not understood by the equal() callback,
    /// the behavior is undefined.
    ///
    /// Returns: The number of times the given value occurs in the array,
    /// within the specified range.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArrayGetCountOfValue")]
    #[inline]
    pub unsafe fn count_of_value(&self, range: CFRange, value: *const c_void) -> CFIndex {
        extern "C-unwind" {
            fn CFArrayGetCountOfValue(
                the_array: &CFArray,
                range: CFRange,
                value: *const c_void,
            ) -> CFIndex;
        }
        unsafe { CFArrayGetCountOfValue(self, range, value) }
    }

    /// Reports whether or not the value is in the array.
    ///
    /// Parameter `theArray`: The array to be searched. If this parameter is not a
    /// valid CFArray, the behavior is undefined.
    ///
    /// Parameter `range`: The range within the array to search. If the range
    /// location or end point (defined by the location plus length
    /// minus 1) is outside the index space of the array (0 to
    /// N-1 inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0).
    ///
    /// Parameter `value`: The value for which to find matches in the array. The
    /// equal() callback provided when the array 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 array, are not understood by the equal() callback,
    /// the behavior is undefined.
    ///
    /// Returns: true, if the value is in the specified range of the array,
    /// otherwise false.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArrayContainsValue")]
    #[inline]
    pub unsafe fn contains_value(&self, range: CFRange, value: *const c_void) -> bool {
        extern "C-unwind" {
            fn CFArrayContainsValue(
                the_array: &CFArray,
                range: CFRange,
                value: *const c_void,
            ) -> Boolean;
        }
        let ret = unsafe { CFArrayContainsValue(self, range, value) };
        ret != 0
    }

    /// Retrieves the value at the given index.
    ///
    /// Parameter `theArray`: The array to be queried. If this parameter is not a
    /// valid CFArray, the behavior is undefined.
    ///
    /// Parameter `idx`: The index of the value to retrieve. If the index is
    /// outside the index space of the array (0 to N-1 inclusive,
    /// where N is the count of the array), the behavior is
    /// undefined.
    ///
    /// Returns: The value with the given index in the array.
    ///
    /// # Safety
    ///
    /// `the_array` generic must be of the correct type.
    #[doc(alias = "CFArrayGetValueAtIndex")]
    #[inline]
    pub unsafe fn value_at_index(&self, idx: CFIndex) -> *const c_void {
        extern "C-unwind" {
            fn CFArrayGetValueAtIndex(the_array: &CFArray, idx: CFIndex) -> *const c_void;
        }
        unsafe { CFArrayGetValueAtIndex(self, idx) }
    }

    /// Fills the buffer with values from the array.
    ///
    /// Parameter `theArray`: The array to be queried. If this parameter is not a
    /// valid CFArray, the behavior is undefined.
    ///
    /// Parameter `range`: The range of values within the array to retrieve. If
    /// the range location or end point (defined by the location
    /// plus length minus 1) is outside the index space of the
    /// array (0 to N-1 inclusive, where N is the count of the
    /// array), the behavior is undefined. If the range length is
    /// negative, the behavior is undefined. The range may be empty
    /// (length 0), in which case no values are put into the buffer.
    ///
    /// Parameter `values`: A C array of pointer-sized values to be filled with
    /// values from the array. The values in the C array are ordered
    /// in the same order in which they appear in the array. If this
    /// parameter is not a valid pointer to a C array of at least
    /// range.length pointers, the behavior is undefined.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `values` must be a valid pointer.
    #[doc(alias = "CFArrayGetValues")]
    #[inline]
    pub unsafe fn values(&self, range: CFRange, values: *mut *const c_void) {
        extern "C-unwind" {
            fn CFArrayGetValues(the_array: &CFArray, range: CFRange, values: *mut *const c_void);
        }
        unsafe { CFArrayGetValues(self, range, values) }
    }

    /// Calls a function once for each value in the array.
    ///
    /// Parameter `theArray`: The array to be operated upon. If this parameter is not
    /// a valid CFArray, the behavior is undefined.
    ///
    /// Parameter `range`: The range of values within the array to which to apply
    /// the function. If the range location or end point (defined by
    /// the location plus length minus 1) is outside the index
    /// space of the array (0 to N-1 inclusive, where N is the count
    /// of the array), the behavior is undefined. If the range
    /// length is negative, the behavior is undefined. The range may
    /// be empty (length 0).
    ///
    /// Parameter `applier`: The callback function to call once for each value in
    /// the given range in the array. If this parameter is not a
    /// pointer to a function of the correct prototype, the behavior
    /// is undefined. If there are values in the range 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 second 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.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `applier` must be implemented correctly.
    /// - `context` must be a valid pointer.
    #[doc(alias = "CFArrayApplyFunction")]
    #[inline]
    pub unsafe fn apply_function(
        &self,
        range: CFRange,
        applier: CFArrayApplierFunction,
        context: *mut c_void,
    ) {
        extern "C-unwind" {
            fn CFArrayApplyFunction(
                the_array: &CFArray,
                range: CFRange,
                applier: CFArrayApplierFunction,
                context: *mut c_void,
            );
        }
        unsafe { CFArrayApplyFunction(self, range, applier, context) }
    }

    /// Searches the array for the value.
    ///
    /// Parameter `theArray`: The array to be searched. If this parameter is not a
    /// valid CFArray, the behavior is undefined.
    ///
    /// Parameter `range`: The range within the array to search. If the range
    /// location or end point (defined by the location plus length
    /// minus 1) is outside the index space of the array (0 to
    /// N-1 inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0).
    /// The search progresses from the smallest index defined by
    /// the range to the largest.
    ///
    /// Parameter `value`: The value for which to find a match in the array. The
    /// equal() callback provided when the array 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 array, are not understood by the equal() callback,
    /// the behavior is undefined.
    ///
    /// Returns: The lowest index of the matching values in the range, or
    /// kCFNotFound if no value in the range matched.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArrayGetFirstIndexOfValue")]
    #[inline]
    pub unsafe fn first_index_of_value(&self, range: CFRange, value: *const c_void) -> CFIndex {
        extern "C-unwind" {
            fn CFArrayGetFirstIndexOfValue(
                the_array: &CFArray,
                range: CFRange,
                value: *const c_void,
            ) -> CFIndex;
        }
        unsafe { CFArrayGetFirstIndexOfValue(self, range, value) }
    }

    /// Searches the array for the value.
    ///
    /// Parameter `theArray`: The array to be searched. If this parameter is not a
    /// valid CFArray, the behavior is undefined.
    ///
    /// Parameter `range`: The range within the array to search. If the range
    /// location or end point (defined by the location plus length
    /// minus 1) is outside the index space of the array (0 to
    /// N-1 inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0).
    /// The search progresses from the largest index defined by the
    /// range to the smallest.
    ///
    /// Parameter `value`: The value for which to find a match in the array. The
    /// equal() callback provided when the array 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 array, are not understood by the equal() callback,
    /// the behavior is undefined.
    ///
    /// Returns: The highest index of the matching values in the range, or
    /// kCFNotFound if no value in the range matched.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArrayGetLastIndexOfValue")]
    #[inline]
    pub unsafe fn last_index_of_value(&self, range: CFRange, value: *const c_void) -> CFIndex {
        extern "C-unwind" {
            fn CFArrayGetLastIndexOfValue(
                the_array: &CFArray,
                range: CFRange,
                value: *const c_void,
            ) -> CFIndex;
        }
        unsafe { CFArrayGetLastIndexOfValue(self, range, value) }
    }

    /// Searches the array for the value using a binary search algorithm.
    ///
    /// Parameter `theArray`: The array to be searched. If this parameter is not a
    /// valid CFArray, the behavior is undefined. If the array is
    /// not sorted from least to greatest according to the
    /// comparator function, the behavior is undefined.
    ///
    /// Parameter `range`: The range within the array to search. If the range
    /// location or end point (defined by the location plus length
    /// minus 1) is outside the index space of the array (0 to
    /// N-1 inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0).
    ///
    /// Parameter `value`: The value for which to find a match in the array. If
    /// value, or any of the values in the array, are not understood
    /// by the comparator callback, the behavior is undefined.
    ///
    /// Parameter `comparator`: The function with the comparator function type
    /// signature which is used in the binary search operation to
    /// compare values in the array with the given value. If this
    /// parameter is not a pointer to a function of the correct
    /// prototype, the behavior is undefined. If there are values
    /// in the range which the comparator function does not expect
    /// or cannot properly compare, the behavior is undefined.
    ///
    /// Parameter `context`: A pointer-sized user-defined value, which is passed
    /// as the third parameter to the comparator function, but is
    /// otherwise unused by this function. If the context is not
    /// what is expected by the comparator function, the behavior is
    /// undefined.
    ///
    /// Returns: The return value is either 1) the index of a value that
    /// matched, if the target value matches one or more in the
    /// range, 2) greater than or equal to the end point of the
    /// range, if the value is greater than all the values in the
    /// range, or 3) the index of the value greater than the target
    /// value, if the value lies between two of (or less than all
    /// of) the values in the range.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    /// - `comparator` must be implemented correctly.
    /// - `context` must be a valid pointer.
    #[doc(alias = "CFArrayBSearchValues")]
    #[inline]
    pub unsafe fn b_search_values(
        &self,
        range: CFRange,
        value: *const c_void,
        comparator: CFComparatorFunction,
        context: *mut c_void,
    ) -> CFIndex {
        extern "C-unwind" {
            fn CFArrayBSearchValues(
                the_array: &CFArray,
                range: CFRange,
                value: *const c_void,
                comparator: CFComparatorFunction,
                context: *mut c_void,
            ) -> CFIndex;
        }
        unsafe { CFArrayBSearchValues(self, range, value, comparator, context) }
    }
}

impl CFMutableArray {
    /// Adds the value to the array giving it a new largest index.
    ///
    /// Parameter `theArray`: The array to which the value is to be added. If this
    /// parameter is not a valid mutable CFArray, the behavior is
    /// undefined.
    ///
    /// Parameter `value`: The value to add to the array. The value is retained by
    /// the array using the retain callback provided when the array
    /// was created. If the value is not of the sort expected by the
    /// retain callback, the behavior is undefined. The value is
    /// assigned to the index one larger than the previous largest
    /// index, and the count of the array is increased by one.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArrayAppendValue")]
    #[inline]
    pub unsafe fn append_value(the_array: Option<&CFMutableArray>, value: *const c_void) {
        extern "C-unwind" {
            fn CFArrayAppendValue(the_array: Option<&CFMutableArray>, value: *const c_void);
        }
        unsafe { CFArrayAppendValue(the_array, value) }
    }

    /// Adds the value to the array, giving it the given index.
    ///
    /// Parameter `theArray`: The array to which the value is to be added. If this
    /// parameter is not a valid mutable CFArray, the behavior is
    /// undefined.
    ///
    /// Parameter `idx`: The index to which to add the new value. If the index is
    /// outside the index space of the array (0 to N inclusive,
    /// where N is the count of the array before the operation), the
    /// behavior is undefined. If the index is the same as N, this
    /// function has the same effect as CFArrayAppendValue().
    ///
    /// Parameter `value`: The value to add to the array. The value is retained by
    /// the array using the retain callback provided when the array
    /// was created. If the value is not of the sort expected by the
    /// retain callback, the behavior is undefined. The value is
    /// assigned to the given index, and all values with equal and
    /// larger indices have their indexes increased by one.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArrayInsertValueAtIndex")]
    #[inline]
    pub unsafe fn insert_value_at_index(
        the_array: Option<&CFMutableArray>,
        idx: CFIndex,
        value: *const c_void,
    ) {
        extern "C-unwind" {
            fn CFArrayInsertValueAtIndex(
                the_array: Option<&CFMutableArray>,
                idx: CFIndex,
                value: *const c_void,
            );
        }
        unsafe { CFArrayInsertValueAtIndex(the_array, idx, value) }
    }

    /// Changes the value with the given index in the array.
    ///
    /// Parameter `theArray`: The array in which the value is to be changed. If this
    /// parameter is not a valid mutable CFArray, the behavior is
    /// undefined.
    ///
    /// Parameter `idx`: The index to which to set the new value. If the index is
    /// outside the index space of the array (0 to N inclusive,
    /// where N is the count of the array before the operation), the
    /// behavior is undefined. If the index is the same as N, this
    /// function has the same effect as CFArrayAppendValue().
    ///
    /// Parameter `value`: The value to set in the array. The value is retained by
    /// the array using the retain callback provided when the array
    /// was created, and the previous value with that index is
    /// released. If the value is not of the sort expected by the
    /// retain callback, the behavior is undefined. The indices of
    /// other values is not affected.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFArraySetValueAtIndex")]
    #[inline]
    pub unsafe fn set_value_at_index(
        the_array: Option<&CFMutableArray>,
        idx: CFIndex,
        value: *const c_void,
    ) {
        extern "C-unwind" {
            fn CFArraySetValueAtIndex(
                the_array: Option<&CFMutableArray>,
                idx: CFIndex,
                value: *const c_void,
            );
        }
        unsafe { CFArraySetValueAtIndex(the_array, idx, value) }
    }

    /// Removes the value with the given index from the array.
    ///
    /// Parameter `theArray`: The array from which the value is to be removed. If
    /// this parameter is not a valid mutable CFArray, the behavior
    /// is undefined.
    ///
    /// Parameter `idx`: The index from which to remove the value. If the index is
    /// outside the index space of the array (0 to N-1 inclusive,
    /// where N is the count of the array before the operation), the
    /// behavior is undefined.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    #[doc(alias = "CFArrayRemoveValueAtIndex")]
    #[inline]
    pub unsafe fn remove_value_at_index(the_array: Option<&CFMutableArray>, idx: CFIndex) {
        extern "C-unwind" {
            fn CFArrayRemoveValueAtIndex(the_array: Option<&CFMutableArray>, idx: CFIndex);
        }
        unsafe { CFArrayRemoveValueAtIndex(the_array, idx) }
    }

    /// Removes all the values from the array, making it empty.
    ///
    /// Parameter `theArray`: The array from which all of the values are to be
    /// removed. If this parameter is not a valid mutable CFArray,
    /// the behavior is undefined.
    #[doc(alias = "CFArrayRemoveAllValues")]
    #[inline]
    pub fn remove_all_values(the_array: Option<&CFMutableArray>) {
        extern "C-unwind" {
            fn CFArrayRemoveAllValues(the_array: Option<&CFMutableArray>);
        }
        unsafe { CFArrayRemoveAllValues(the_array) }
    }

    /// Replaces a range of values in the array.
    ///
    /// Parameter `theArray`: The array from which all of the values are to be
    /// removed. If this parameter is not a valid mutable CFArray,
    /// the behavior is undefined.
    ///
    /// Parameter `range`: The range of values within the array to replace. If the
    /// range location or end point (defined by the location plus
    /// length minus 1) is outside the index space of the array (0
    /// to N inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0),
    /// in which case the new values are merely inserted at the
    /// range location.
    ///
    /// Parameter `newValues`: A C array of the pointer-sized values to be placed
    /// into the array. The new values in the array are ordered in
    /// the same order in which they appear in this C array. This
    /// parameter may be NULL if the newCount parameter is 0. This
    /// C array is not changed or freed by this function. If this
    /// parameter is not a valid pointer to a C array of at least
    /// newCount pointers, the behavior is undefined.
    ///
    /// Parameter `newCount`: The number of values to copy from the values C
    /// array into the CFArray. If this parameter is different than
    /// the range length, the excess newCount values will be
    /// inserted after the range, or the excess range values will be
    /// deleted. This parameter may be 0, in which case no new
    /// values are replaced into the array and the values in the
    /// range are simply removed. If this parameter is negative, or
    /// greater than the number of values actually in the newValues
    /// C array, the behavior is undefined.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - `new_values` must be a valid pointer.
    #[doc(alias = "CFArrayReplaceValues")]
    #[inline]
    pub unsafe fn replace_values(
        the_array: Option<&CFMutableArray>,
        range: CFRange,
        new_values: *mut *const c_void,
        new_count: CFIndex,
    ) {
        extern "C-unwind" {
            fn CFArrayReplaceValues(
                the_array: Option<&CFMutableArray>,
                range: CFRange,
                new_values: *mut *const c_void,
                new_count: CFIndex,
            );
        }
        unsafe { CFArrayReplaceValues(the_array, range, new_values, new_count) }
    }

    /// Exchanges the values at two indices of the array.
    ///
    /// Parameter `theArray`: The array of which the values are to be swapped. If
    /// this parameter is not a valid mutable CFArray, the behavior
    /// is undefined.
    ///
    /// Parameter `idx1`: The first index whose values should be swapped. If the
    /// index is outside the index space of the array (0 to N-1
    /// inclusive, where N is the count of the array before the
    /// operation), the behavior is undefined.
    ///
    /// Parameter `idx2`: The second index whose values should be swapped. If the
    /// index is outside the index space of the array (0 to N-1
    /// inclusive, where N is the count of the array before the
    /// operation), the behavior is undefined.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    #[doc(alias = "CFArrayExchangeValuesAtIndices")]
    #[inline]
    pub unsafe fn exchange_values_at_indices(
        the_array: Option<&CFMutableArray>,
        idx1: CFIndex,
        idx2: CFIndex,
    ) {
        extern "C-unwind" {
            fn CFArrayExchangeValuesAtIndices(
                the_array: Option<&CFMutableArray>,
                idx1: CFIndex,
                idx2: CFIndex,
            );
        }
        unsafe { CFArrayExchangeValuesAtIndices(the_array, idx1, idx2) }
    }

    /// Sorts the values in the array using the given comparison function.
    ///
    /// Parameter `theArray`: The array whose values are to be sorted. If this
    /// parameter is not a valid mutable CFArray, the behavior is
    /// undefined.
    ///
    /// Parameter `range`: The range of values within the array to sort. If the
    /// range location or end point (defined by the location plus
    /// length minus 1) is outside the index space of the array (0
    /// to N-1 inclusive, where N is the count of the array), the
    /// behavior is undefined. If the range length is negative, the
    /// behavior is undefined. The range may be empty (length 0).
    ///
    /// Parameter `comparator`: The function with the comparator function type
    /// signature which is used in the sort operation to compare
    /// values in the array with the given value. If this parameter
    /// is not a pointer to a function of the correct prototype, the
    /// the behavior is undefined. If there are values in the array
    /// which the comparator function does not expect or cannot
    /// properly compare, the behavior is undefined. The values in
    /// the range are sorted from least to greatest according to
    /// this function.
    ///
    /// Parameter `context`: A pointer-sized user-defined value, which is passed
    /// as the third parameter to the comparator function, but is
    /// otherwise unused by this function. If the context is not
    /// what is expected by the comparator function, the behavior is
    /// undefined.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - `comparator` must be implemented correctly.
    /// - `context` must be a valid pointer.
    #[doc(alias = "CFArraySortValues")]
    #[inline]
    pub unsafe fn sort_values(
        the_array: Option<&CFMutableArray>,
        range: CFRange,
        comparator: CFComparatorFunction,
        context: *mut c_void,
    ) {
        extern "C-unwind" {
            fn CFArraySortValues(
                the_array: Option<&CFMutableArray>,
                range: CFRange,
                comparator: CFComparatorFunction,
                context: *mut c_void,
            );
        }
        unsafe { CFArraySortValues(the_array, range, comparator, context) }
    }

    /// Adds the values from an array to another array.
    ///
    /// Parameter `theArray`: The array to which values from the otherArray are to
    /// be added. If this parameter is not a valid mutable CFArray,
    /// the behavior is undefined.
    ///
    /// Parameter `otherArray`: The array providing the values to be added to the
    /// array. If this parameter is not a valid CFArray, the
    /// behavior is undefined.
    ///
    /// Parameter `otherRange`: The range within the otherArray from which to add
    /// the values to the array. If the range location or end point
    /// (defined by the location plus length minus 1) is outside
    /// the index space of the otherArray (0 to N-1 inclusive, where
    /// N is the count of the otherArray), the behavior is
    /// undefined. The new values are retained by the array using
    /// the retain callback provided when the array was created. If
    /// the values are not of the sort expected by the retain
    /// callback, the behavior is undefined. The values are assigned
    /// to the indices one larger than the previous largest index
    /// in the array, and beyond, and the count of the array is
    /// increased by range.length. The values are assigned new
    /// indices in the array from smallest to largest index in the
    /// order in which they appear in the otherArray.
    ///
    /// # Safety
    ///
    /// - `the_array` generic must be of the correct type.
    /// - `the_array` might not allow `None`.
    /// - `other_array` generic must be of the correct type.
    /// - `other_array` might not allow `None`.
    #[doc(alias = "CFArrayAppendArray")]
    #[inline]
    pub unsafe fn append_array(
        the_array: Option<&CFMutableArray>,
        other_array: Option<&CFArray>,
        other_range: CFRange,
    ) {
        extern "C-unwind" {
            fn CFArrayAppendArray(
                the_array: Option<&CFMutableArray>,
                other_array: Option<&CFArray>,
                other_range: CFRange,
            );
        }
        unsafe { CFArrayAppendArray(the_array, other_array, other_range) }
    }
}

#[deprecated = "renamed to `CFArray::new`"]
#[inline]
pub unsafe extern "C-unwind" fn CFArrayCreate(
    allocator: Option<&CFAllocator>,
    values: *mut *const c_void,
    num_values: CFIndex,
    call_backs: *const CFArrayCallBacks,
) -> Option<CFRetained<CFArray>> {
    extern "C-unwind" {
        fn CFArrayCreate(
            allocator: Option<&CFAllocator>,
            values: *mut *const c_void,
            num_values: CFIndex,
            call_backs: *const CFArrayCallBacks,
        ) -> Option<NonNull<CFArray>>;
    }
    let ret = unsafe { CFArrayCreate(allocator, values, num_values, call_backs) };
    ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
}

#[deprecated = "renamed to `CFArray::new_copy`"]
#[inline]
pub unsafe extern "C-unwind" fn CFArrayCreateCopy(
    allocator: Option<&CFAllocator>,
    the_array: Option<&CFArray>,
) -> Option<CFRetained<CFArray>> {
    extern "C-unwind" {
        fn CFArrayCreateCopy(
            allocator: Option<&CFAllocator>,
            the_array: Option<&CFArray>,
        ) -> Option<NonNull<CFArray>>;
    }
    let ret = unsafe { CFArrayCreateCopy(allocator, the_array) };
    ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
}

#[deprecated = "renamed to `CFMutableArray::new`"]
#[inline]
pub unsafe extern "C-unwind" fn CFArrayCreateMutable(
    allocator: Option<&CFAllocator>,
    capacity: CFIndex,
    call_backs: *const CFArrayCallBacks,
) -> Option<CFRetained<CFMutableArray>> {
    extern "C-unwind" {
        fn CFArrayCreateMutable(
            allocator: Option<&CFAllocator>,
            capacity: CFIndex,
            call_backs: *const CFArrayCallBacks,
        ) -> Option<NonNull<CFMutableArray>>;
    }
    let ret = unsafe { CFArrayCreateMutable(allocator, capacity, call_backs) };
    ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
}

#[deprecated = "renamed to `CFMutableArray::new_copy`"]
#[inline]
pub unsafe extern "C-unwind" fn CFArrayCreateMutableCopy(
    allocator: Option<&CFAllocator>,
    capacity: CFIndex,
    the_array: Option<&CFArray>,
) -> Option<CFRetained<CFMutableArray>> {
    extern "C-unwind" {
        fn CFArrayCreateMutableCopy(
            allocator: Option<&CFAllocator>,
            capacity: CFIndex,
            the_array: Option<&CFArray>,
        ) -> Option<NonNull<CFMutableArray>>;
    }
    let ret = unsafe { CFArrayCreateMutableCopy(allocator, capacity, the_array) };
    ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
}

#[deprecated = "renamed to `CFArray::count`"]
#[inline]
pub extern "C-unwind" fn CFArrayGetCount(the_array: &CFArray) -> CFIndex {
    extern "C-unwind" {
        fn CFArrayGetCount(the_array: &CFArray) -> CFIndex;
    }
    unsafe { CFArrayGetCount(the_array) }
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::count_of_value`"]
    pub fn CFArrayGetCountOfValue(
        the_array: &CFArray,
        range: CFRange,
        value: *const c_void,
    ) -> CFIndex;
}

#[deprecated = "renamed to `CFArray::contains_value`"]
#[inline]
pub unsafe extern "C-unwind" fn CFArrayContainsValue(
    the_array: &CFArray,
    range: CFRange,
    value: *const c_void,
) -> bool {
    extern "C-unwind" {
        fn CFArrayContainsValue(
            the_array: &CFArray,
            range: CFRange,
            value: *const c_void,
        ) -> Boolean;
    }
    let ret = unsafe { CFArrayContainsValue(the_array, range, value) };
    ret != 0
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::value_at_index`"]
    pub fn CFArrayGetValueAtIndex(the_array: &CFArray, idx: CFIndex) -> *const c_void;
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::values`"]
    pub fn CFArrayGetValues(the_array: &CFArray, range: CFRange, values: *mut *const c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::apply_function`"]
    pub fn CFArrayApplyFunction(
        the_array: &CFArray,
        range: CFRange,
        applier: CFArrayApplierFunction,
        context: *mut c_void,
    );
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::first_index_of_value`"]
    pub fn CFArrayGetFirstIndexOfValue(
        the_array: &CFArray,
        range: CFRange,
        value: *const c_void,
    ) -> CFIndex;
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::last_index_of_value`"]
    pub fn CFArrayGetLastIndexOfValue(
        the_array: &CFArray,
        range: CFRange,
        value: *const c_void,
    ) -> CFIndex;
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFArray::b_search_values`"]
    pub fn CFArrayBSearchValues(
        the_array: &CFArray,
        range: CFRange,
        value: *const c_void,
        comparator: CFComparatorFunction,
        context: *mut c_void,
    ) -> CFIndex;
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::append_value`"]
    pub fn CFArrayAppendValue(the_array: Option<&CFMutableArray>, value: *const c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::insert_value_at_index`"]
    pub fn CFArrayInsertValueAtIndex(
        the_array: Option<&CFMutableArray>,
        idx: CFIndex,
        value: *const c_void,
    );
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::set_value_at_index`"]
    pub fn CFArraySetValueAtIndex(
        the_array: Option<&CFMutableArray>,
        idx: CFIndex,
        value: *const c_void,
    );
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::remove_value_at_index`"]
    pub fn CFArrayRemoveValueAtIndex(the_array: Option<&CFMutableArray>, idx: CFIndex);
}

#[deprecated = "renamed to `CFMutableArray::remove_all_values`"]
#[inline]
pub extern "C-unwind" fn CFArrayRemoveAllValues(the_array: Option<&CFMutableArray>) {
    extern "C-unwind" {
        fn CFArrayRemoveAllValues(the_array: Option<&CFMutableArray>);
    }
    unsafe { CFArrayRemoveAllValues(the_array) }
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::replace_values`"]
    pub fn CFArrayReplaceValues(
        the_array: Option<&CFMutableArray>,
        range: CFRange,
        new_values: *mut *const c_void,
        new_count: CFIndex,
    );
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::exchange_values_at_indices`"]
    pub fn CFArrayExchangeValuesAtIndices(
        the_array: Option<&CFMutableArray>,
        idx1: CFIndex,
        idx2: CFIndex,
    );
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::sort_values`"]
    pub fn CFArraySortValues(
        the_array: Option<&CFMutableArray>,
        range: CFRange,
        comparator: CFComparatorFunction,
        context: *mut c_void,
    );
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableArray::append_array`"]
    pub fn CFArrayAppendArray(
        the_array: Option<&CFMutableArray>,
        other_array: Option<&CFArray>,
        other_range: CFRange,
    );
}