//! 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::*;

/// Type of the callback function used by CFSets for retaining values.
///
/// Parameter `allocator`: The allocator of the CFSet.
///
/// Parameter `value`: The value to retain.
///
/// Returns: The value to store in the set, 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 set.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfsetretaincallback?language=objc)
pub type CFSetRetainCallBack =
    Option<unsafe extern "C-unwind" fn(*const CFAllocator, *const c_void) -> *const c_void>;

/// Type of the callback function used by CFSets for releasing a retain on values.
///
/// Parameter `allocator`: The allocator of the CFSet.
///
/// Parameter `value`: The value to release.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfsetreleasecallback?language=objc)
pub type CFSetReleaseCallBack =
    Option<unsafe extern "C-unwind" fn(*const CFAllocator, *const c_void)>;

/// Type of the callback function used by CFSets for describing values.
///
/// Parameter `value`: The value to describe.
///
/// Returns: A description of the specified value.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfsetcopydescriptioncallback?language=objc)
pub type CFSetCopyDescriptionCallBack =
    Option<unsafe extern "C-unwind" fn(*const c_void) -> *const CFString>;

/// Type of the callback function used by CFSets for comparing values.
///
/// Parameter `value1`: The first value to compare.
///
/// Parameter `value2`: The second value to compare.
///
/// Returns: True if the values are equal, otherwise false.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfsetequalcallback?language=objc)
pub type CFSetEqualCallBack =
    Option<unsafe extern "C-unwind" fn(*const c_void, *const c_void) -> Boolean>;

/// Type of the callback function used by CFSets for hashing values.
///
/// Parameter `value`: The value to hash.
///
/// Returns: The hash of the value.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfsethashcallback?language=objc)
pub type CFSetHashCallBack = Option<unsafe extern "C-unwind" fn(*const c_void) -> CFHashCode>;

/// Structure containing the callbacks of a CFSet.
/// Field: version The version number of the structure type being passed
/// in as a parameter to the CFSet creation functions. This
/// structure is version 0.
/// Field: retain The callback used to add a retain for the set on
/// values as they are put into the set. This callback returns
/// the value to store in the set, 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 set.
/// The set's allocator is passed as the first argument.
/// Field: release The callback used to remove a retain previously added
/// for the set from values as they are removed from the
/// set. The set's allocator is passed as the first
/// argument.
/// Field: copyDescription The callback used to create a descriptive
/// string representation of each value in the set. This is
/// used by the CFCopyDescription() function.
/// Field: equal The callback used to compare values in the set for
/// equality for some operations.
/// Field: hash The callback used to compare values in the set for
/// uniqueness for some operations.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/cfsetcallbacks?language=objc)
#[repr(C)]
#[allow(unpredictable_function_pointer_comparisons)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CFSetCallBacks {
    pub version: CFIndex,
    pub retain: CFSetRetainCallBack,
    pub release: CFSetReleaseCallBack,
    pub copyDescription: CFSetCopyDescriptionCallBack,
    pub equal: CFSetEqualCallBack,
    pub hash: CFSetHashCallBack,
}

#[cfg(feature = "objc2")]
unsafe impl Encode for CFSetCallBacks {
    const ENCODING: Encoding = Encoding::Struct(
        "?",
        &[
            <CFIndex>::ENCODING,
            <CFSetRetainCallBack>::ENCODING,
            <CFSetReleaseCallBack>::ENCODING,
            <CFSetCopyDescriptionCallBack>::ENCODING,
            <CFSetEqualCallBack>::ENCODING,
            <CFSetHashCallBack>::ENCODING,
        ],
    );
}

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

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

extern "C" {
    /// Predefined CFSetCallBacks structure containing a set of callbacks
    /// appropriate for use when the values in a CFSet should be copies
    /// of a CFString.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/corefoundation/kcfcopystringsetcallbacks?language=objc)
    pub static kCFCopyStringSetCallBacks: CFSetCallBacks;
}

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

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

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

impl<T: ?Sized> CFSet<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) -> &CFSet<NewT> {
        unsafe { &*((self as *const Self).cast()) }
    }

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

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

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

impl<T: ?Sized> CFMutableSet<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) -> &CFMutableSet<NewT> {
        unsafe { &*((self as *const Self).cast()) }
    }

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

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

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

    /// Creates a new immutable set with the values from the given set.
    ///
    /// Parameter `allocator`: The CFAllocator which should be used to allocate
    /// memory for the set 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 `theSet`: The set which is to be copied. The values from the
    /// set are copied as pointers into the new set (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 set. The count of the new set will
    /// be the same as the copied set. The new set uses the same
    /// callbacks as the set to be copied. If this parameter is
    /// not a valid CFSet, the behavior is undefined.
    ///
    /// Returns: A reference to the new immutable CFSet.
    #[doc(alias = "CFSetCreateCopy")]
    #[inline]
    pub fn new_copy(
        allocator: Option<&CFAllocator>,
        the_set: Option<&CFSet>,
    ) -> Option<CFRetained<CFSet>> {
        extern "C-unwind" {
            fn CFSetCreateCopy(
                allocator: Option<&CFAllocator>,
                the_set: Option<&CFSet>,
            ) -> Option<NonNull<CFSet>>;
        }
        let ret = unsafe { CFSetCreateCopy(allocator, the_set) };
        ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
    }
}

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

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

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

    /// Counts the number of times the given value occurs in the set. Since
    /// sets by definition contain only one instance of a value, this function
    /// is synonymous to CFSetContainsValue.
    ///
    /// Parameter `theSet`: The set to be searched. If this parameter is not a
    /// valid CFSet, the behavior is undefined.
    ///
    /// Parameter `value`: The value for which to find matches in the set. The
    /// equal() callback provided when the set 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 set, are not understood by the equal() callback,
    /// the behavior is undefined.
    ///
    /// Returns: The number of times the given value occurs in the set.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetGetCountOfValue")]
    #[inline]
    pub unsafe fn count_of_value(&self, value: *const c_void) -> CFIndex {
        extern "C-unwind" {
            fn CFSetGetCountOfValue(the_set: &CFSet, value: *const c_void) -> CFIndex;
        }
        unsafe { CFSetGetCountOfValue(self, value) }
    }

    /// Reports whether or not the value is in the set.
    ///
    /// Parameter `theSet`: The set to be searched. If this parameter is not a
    /// valid CFSet, the behavior is undefined.
    ///
    /// Parameter `value`: The value for which to find matches in the set. The
    /// equal() callback provided when the set 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 set, are not understood by the equal() callback,
    /// the behavior is undefined.
    ///
    /// Returns: true, if the value is in the set, otherwise false.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetContainsValue")]
    #[inline]
    pub unsafe fn contains_value(&self, value: *const c_void) -> bool {
        extern "C-unwind" {
            fn CFSetContainsValue(the_set: &CFSet, value: *const c_void) -> Boolean;
        }
        let ret = unsafe { CFSetContainsValue(self, value) };
        ret != 0
    }

    /// Retrieves a value in the set which hashes the same as the specified value.
    ///
    /// Parameter `theSet`: The set to be queried. If this parameter is not a
    /// valid CFSet, the behavior is undefined.
    ///
    /// Parameter `value`: The value to retrieve. The equal() callback provided when
    /// the set was created is used to compare. If the equal() callback
    /// was NULL, pointer equality (in C, ==) is used. If a value, or
    /// any of the values in the set, are not understood by the equal()
    /// callback, the behavior is undefined.
    ///
    /// Returns: The value in the set with the given hash.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetGetValue")]
    #[inline]
    pub unsafe fn value(&self, value: *const c_void) -> *const c_void {
        extern "C-unwind" {
            fn CFSetGetValue(the_set: &CFSet, value: *const c_void) -> *const c_void;
        }
        unsafe { CFSetGetValue(self, value) }
    }

    /// Retrieves a value in the set which hashes the same as the specified value,
    /// if present.
    ///
    /// Parameter `theSet`: The set to be queried. If this parameter is not a
    /// valid CFSet, the behavior is undefined.
    ///
    /// Parameter `candidate`: This value is hashed and compared with values in the
    /// set to determine which value to retrieve. The equal() callback provided when
    /// the set was created is used to compare. If the equal() callback
    /// was NULL, pointer equality (in C, ==) is used. If a value, or
    /// any of the values in the set, 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 value is found. If no
    /// 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 value was present).
    ///
    /// Returns: True if the value was present in the set, otherwise false.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `candidate` must be a valid pointer.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetGetValueIfPresent")]
    #[inline]
    pub unsafe fn value_if_present(
        &self,
        candidate: *const c_void,
        value: *mut *const c_void,
    ) -> bool {
        extern "C-unwind" {
            fn CFSetGetValueIfPresent(
                the_set: &CFSet,
                candidate: *const c_void,
                value: *mut *const c_void,
            ) -> Boolean;
        }
        let ret = unsafe { CFSetGetValueIfPresent(self, candidate, value) };
        ret != 0
    }

    /// Fills the buffer with values from the set.
    ///
    /// Parameter `theSet`: The set to be queried. If this parameter is not a
    /// valid CFSet, the behavior is undefined.
    ///
    /// Parameter `values`: A C array of pointer-sized values to be filled with
    /// values from the set. The values in the C array are ordered
    /// in the same order in which they appear in the set. If this
    /// parameter is not a valid pointer to a C array of at least
    /// CFSetGetCount() pointers, the behavior is undefined.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `values` must be a valid pointer.
    #[doc(alias = "CFSetGetValues")]
    #[inline]
    pub unsafe fn values(&self, values: *mut *const c_void) {
        extern "C-unwind" {
            fn CFSetGetValues(the_set: &CFSet, values: *mut *const c_void);
        }
        unsafe { CFSetGetValues(self, values) }
    }

    /// Calls a function once for each value in the set.
    ///
    /// Parameter `theSet`: The set to be operated upon. If this parameter is not
    /// a valid CFSet, the behavior is undefined.
    ///
    /// Parameter `applier`: The callback function to call once for each value in
    /// the given set. If this parameter is not a
    /// pointer to a function of the correct prototype, the behavior
    /// is undefined. If there are values in the set 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_set` generic must be of the correct type.
    /// - `applier` must be implemented correctly.
    /// - `context` must be a valid pointer.
    #[doc(alias = "CFSetApplyFunction")]
    #[inline]
    pub unsafe fn apply_function(&self, applier: CFSetApplierFunction, context: *mut c_void) {
        extern "C-unwind" {
            fn CFSetApplyFunction(
                the_set: &CFSet,
                applier: CFSetApplierFunction,
                context: *mut c_void,
            );
        }
        unsafe { CFSetApplyFunction(self, applier, context) }
    }
}

impl CFMutableSet {
    /// Adds the value to the set if it is not already present.
    ///
    /// Parameter `theSet`: The set to which the value is to be added. If this
    /// parameter is not a valid mutable CFSet, the behavior is
    /// undefined.
    ///
    /// Parameter `value`: The value to add to the set. The value is retained by
    /// the set using the retain callback provided when the set
    /// was created. If the value is not of the sort expected by the
    /// retain callback, the behavior is undefined. The count of the
    /// set is increased by one.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `the_set` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetAddValue")]
    #[inline]
    pub unsafe fn add_value(the_set: Option<&CFMutableSet>, value: *const c_void) {
        extern "C-unwind" {
            fn CFSetAddValue(the_set: Option<&CFMutableSet>, value: *const c_void);
        }
        unsafe { CFSetAddValue(the_set, value) }
    }

    /// Replaces the value in the set if it is present.
    ///
    /// Parameter `theSet`: The set to which the value is to be replaced. If this
    /// parameter is not a valid mutable CFSet, the behavior is
    /// undefined.
    ///
    /// Parameter `value`: The value to replace in the set. The equal() callback provided when
    /// the set was created is used to compare. If the equal() callback
    /// was NULL, pointer equality (in C, ==) is used. If a value, or
    /// any of the values in the set, are not understood by the equal()
    /// callback, the behavior is undefined. The value is retained by
    /// the set using the retain callback provided when the set
    /// was created. If the value is not of the sort expected by the
    /// retain callback, the behavior is undefined. The count of the
    /// set is increased by one.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `the_set` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetReplaceValue")]
    #[inline]
    pub unsafe fn replace_value(the_set: Option<&CFMutableSet>, value: *const c_void) {
        extern "C-unwind" {
            fn CFSetReplaceValue(the_set: Option<&CFMutableSet>, value: *const c_void);
        }
        unsafe { CFSetReplaceValue(the_set, value) }
    }

    /// Replaces the value in the set if it is present, or adds the value to
    /// the set if it is absent.
    ///
    /// Parameter `theSet`: The set to which the value is to be replaced. If this
    /// parameter is not a valid mutable CFSet, the behavior is
    /// undefined.
    ///
    /// Parameter `value`: The value to set in the CFSet. The equal() callback provided when
    /// the set was created is used to compare. If the equal() callback
    /// was NULL, pointer equality (in C, ==) is used. If a value, or
    /// any of the values in the set, are not understood by the equal()
    /// callback, the behavior is undefined. The value is retained by
    /// the set using the retain callback provided when the set
    /// was created. If the value is not of the sort expected by the
    /// retain callback, the behavior is undefined. The count of the
    /// set is increased by one.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `the_set` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetSetValue")]
    #[inline]
    pub unsafe fn set_value(the_set: Option<&CFMutableSet>, value: *const c_void) {
        extern "C-unwind" {
            fn CFSetSetValue(the_set: Option<&CFMutableSet>, value: *const c_void);
        }
        unsafe { CFSetSetValue(the_set, value) }
    }

    /// Removes the specified value from the set.
    ///
    /// Parameter `theSet`: The set from which the value is to be removed.
    /// If this parameter is not a valid mutable CFSet,
    /// the behavior is undefined.
    ///
    /// Parameter `value`: The value to remove. The equal() callback provided when
    /// the set was created is used to compare. If the equal() callback
    /// was NULL, pointer equality (in C, ==) is used. If a value, or
    /// any of the values in the set, are not understood by the equal()
    /// callback, the behavior is undefined.
    ///
    /// # Safety
    ///
    /// - `the_set` generic must be of the correct type.
    /// - `the_set` might not allow `None`.
    /// - `value` must be a valid pointer.
    #[doc(alias = "CFSetRemoveValue")]
    #[inline]
    pub unsafe fn remove_value(the_set: Option<&CFMutableSet>, value: *const c_void) {
        extern "C-unwind" {
            fn CFSetRemoveValue(the_set: Option<&CFMutableSet>, value: *const c_void);
        }
        unsafe { CFSetRemoveValue(the_set, value) }
    }

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

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

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

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

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

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

extern "C-unwind" {
    #[deprecated = "renamed to `CFSet::count_of_value`"]
    pub fn CFSetGetCountOfValue(the_set: &CFSet, value: *const c_void) -> CFIndex;
}

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

extern "C-unwind" {
    #[deprecated = "renamed to `CFSet::value`"]
    pub fn CFSetGetValue(the_set: &CFSet, value: *const c_void) -> *const c_void;
}

#[deprecated = "renamed to `CFSet::value_if_present`"]
#[inline]
pub unsafe extern "C-unwind" fn CFSetGetValueIfPresent(
    the_set: &CFSet,
    candidate: *const c_void,
    value: *mut *const c_void,
) -> bool {
    extern "C-unwind" {
        fn CFSetGetValueIfPresent(
            the_set: &CFSet,
            candidate: *const c_void,
            value: *mut *const c_void,
        ) -> Boolean;
    }
    let ret = unsafe { CFSetGetValueIfPresent(the_set, candidate, value) };
    ret != 0
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFSet::values`"]
    pub fn CFSetGetValues(the_set: &CFSet, values: *mut *const c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFSet::apply_function`"]
    pub fn CFSetApplyFunction(the_set: &CFSet, applier: CFSetApplierFunction, context: *mut c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableSet::add_value`"]
    pub fn CFSetAddValue(the_set: Option<&CFMutableSet>, value: *const c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableSet::replace_value`"]
    pub fn CFSetReplaceValue(the_set: Option<&CFMutableSet>, value: *const c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableSet::set_value`"]
    pub fn CFSetSetValue(the_set: Option<&CFMutableSet>, value: *const c_void);
}

extern "C-unwind" {
    #[deprecated = "renamed to `CFMutableSet::remove_value`"]
    pub fn CFSetRemoveValue(the_set: Option<&CFMutableSet>, value: *const c_void);
}

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