Source code
Revision control
Copy as Markdown
Other Tools
//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use crate::*;
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtablestrongmemory?language=objc)
#[cfg(feature = "NSPointerFunctions")]
pub static NSHashTableStrongMemory: NSPointerFunctionsOptions =
NSPointerFunctionsOptions(NSPointerFunctionsOptions::StrongMemory.0);
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtablezeroingweakmemory?language=objc)
#[cfg(feature = "NSPointerFunctions")]
#[deprecated = "GC no longer supported"]
pub static NSHashTableZeroingWeakMemory: NSPointerFunctionsOptions =
NSPointerFunctionsOptions(NSPointerFunctionsOptions::ZeroingWeakMemory.0);
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtablecopyin?language=objc)
#[cfg(feature = "NSPointerFunctions")]
pub static NSHashTableCopyIn: NSPointerFunctionsOptions =
NSPointerFunctionsOptions(NSPointerFunctionsOptions::CopyIn.0);
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtableobjectpointerpersonality?language=objc)
#[cfg(feature = "NSPointerFunctions")]
pub static NSHashTableObjectPointerPersonality: NSPointerFunctionsOptions =
NSPointerFunctionsOptions(NSPointerFunctionsOptions::ObjectPointerPersonality.0);
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtableweakmemory?language=objc)
#[cfg(feature = "NSPointerFunctions")]
pub static NSHashTableWeakMemory: NSPointerFunctionsOptions =
NSPointerFunctionsOptions(NSPointerFunctionsOptions::WeakMemory.0);
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtableoptions?language=objc)
pub type NSHashTableOptions = NSUInteger;
extern_class!(
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtable?language=objc)
#[unsafe(super(NSObject))]
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct NSHashTable<ObjectType: ?Sized = AnyObject>;
);
impl<ObjectType: ?Sized + Message> NSHashTable<ObjectType> {
/// Unchecked conversion of the generic parameter.
///
/// # Safety
///
/// The generic must be valid to reinterpret as the given type.
#[inline]
pub unsafe fn cast_unchecked<NewObjectType: ?Sized + Message>(
&self,
) -> &NSHashTable<NewObjectType> {
unsafe { &*((self as *const Self).cast()) }
}
}
#[cfg(feature = "NSObject")]
extern_conformance!(
unsafe impl<ObjectType: ?Sized + NSCoding> NSCoding for NSHashTable<ObjectType> {}
);
#[cfg(feature = "NSObject")]
extern_conformance!(
unsafe impl<ObjectType: ?Sized> NSCopying for NSHashTable<ObjectType> {}
);
#[cfg(feature = "NSObject")]
unsafe impl<ObjectType: ?Sized + Message> CopyingHelper for NSHashTable<ObjectType> {
type Result = Self;
}
#[cfg(feature = "NSEnumerator")]
extern_conformance!(
unsafe impl<ObjectType: ?Sized> NSFastEnumeration for NSHashTable<ObjectType> {}
);
extern_conformance!(
unsafe impl<ObjectType: ?Sized> NSObjectProtocol for NSHashTable<ObjectType> {}
);
#[cfg(feature = "NSObject")]
extern_conformance!(
unsafe impl<ObjectType: ?Sized + NSSecureCoding> NSSecureCoding for NSHashTable<ObjectType> {}
);
impl<ObjectType: Message> NSHashTable<ObjectType> {
extern_methods!(
#[cfg(feature = "NSPointerFunctions")]
#[unsafe(method(initWithOptions:capacity:))]
#[unsafe(method_family = init)]
pub fn initWithOptions_capacity(
this: Allocated<Self>,
options: NSPointerFunctionsOptions,
initial_capacity: NSUInteger,
) -> Retained<Self>;
#[cfg(feature = "NSPointerFunctions")]
#[unsafe(method(initWithPointerFunctions:capacity:))]
#[unsafe(method_family = init)]
pub fn initWithPointerFunctions_capacity(
this: Allocated<Self>,
functions: &NSPointerFunctions,
initial_capacity: NSUInteger,
) -> Retained<Self>;
#[cfg(feature = "NSPointerFunctions")]
#[unsafe(method(hashTableWithOptions:))]
#[unsafe(method_family = none)]
pub fn hashTableWithOptions(
options: NSPointerFunctionsOptions,
) -> Retained<NSHashTable<ObjectType>>;
#[deprecated = "GC no longer supported"]
#[unsafe(method(hashTableWithWeakObjects))]
#[unsafe(method_family = none)]
pub fn hashTableWithWeakObjects() -> Retained<AnyObject>;
#[unsafe(method(weakObjectsHashTable))]
#[unsafe(method_family = none)]
pub fn weakObjectsHashTable() -> Retained<NSHashTable<ObjectType>>;
#[cfg(feature = "NSPointerFunctions")]
#[unsafe(method(pointerFunctions))]
#[unsafe(method_family = none)]
pub fn pointerFunctions(&self) -> Retained<NSPointerFunctions>;
#[unsafe(method(count))]
#[unsafe(method_family = none)]
pub fn count(&self) -> NSUInteger;
#[unsafe(method(member:))]
#[unsafe(method_family = none)]
pub fn member(&self, object: Option<&ObjectType>) -> Option<Retained<ObjectType>>;
#[cfg(feature = "NSEnumerator")]
/// # Safety
///
/// The returned enumerator's underlying collection should not be mutated while in use.
#[unsafe(method(objectEnumerator))]
#[unsafe(method_family = none)]
pub unsafe fn objectEnumerator(&self) -> Retained<NSEnumerator<ObjectType>>;
#[unsafe(method(addObject:))]
#[unsafe(method_family = none)]
pub fn addObject(&self, object: Option<&ObjectType>);
#[unsafe(method(removeObject:))]
#[unsafe(method_family = none)]
pub fn removeObject(&self, object: Option<&ObjectType>);
#[unsafe(method(removeAllObjects))]
#[unsafe(method_family = none)]
pub fn removeAllObjects(&self);
#[cfg(feature = "NSArray")]
#[unsafe(method(allObjects))]
#[unsafe(method_family = none)]
pub fn allObjects(&self) -> Retained<NSArray<ObjectType>>;
#[unsafe(method(anyObject))]
#[unsafe(method_family = none)]
pub fn anyObject(&self) -> Option<Retained<ObjectType>>;
#[unsafe(method(containsObject:))]
#[unsafe(method_family = none)]
pub fn containsObject(&self, an_object: Option<&ObjectType>) -> bool;
#[unsafe(method(intersectsHashTable:))]
#[unsafe(method_family = none)]
pub fn intersectsHashTable(&self, other: &NSHashTable<ObjectType>) -> bool;
#[unsafe(method(isEqualToHashTable:))]
#[unsafe(method_family = none)]
pub fn isEqualToHashTable(&self, other: &NSHashTable<ObjectType>) -> bool;
#[unsafe(method(isSubsetOfHashTable:))]
#[unsafe(method_family = none)]
pub fn isSubsetOfHashTable(&self, other: &NSHashTable<ObjectType>) -> bool;
#[unsafe(method(intersectHashTable:))]
#[unsafe(method_family = none)]
pub fn intersectHashTable(&self, other: &NSHashTable<ObjectType>);
#[unsafe(method(unionHashTable:))]
#[unsafe(method_family = none)]
pub fn unionHashTable(&self, other: &NSHashTable<ObjectType>);
#[unsafe(method(minusHashTable:))]
#[unsafe(method_family = none)]
pub fn minusHashTable(&self, other: &NSHashTable<ObjectType>);
#[cfg(feature = "NSSet")]
#[unsafe(method(setRepresentation))]
#[unsafe(method_family = none)]
pub fn setRepresentation(&self) -> Retained<NSSet<ObjectType>>;
);
}
/// Methods declared on superclass `NSObject`.
impl<ObjectType: Message> NSHashTable<ObjectType> {
extern_methods!(
#[unsafe(method(init))]
#[unsafe(method_family = init)]
pub fn init(this: Allocated<Self>) -> Retained<Self>;
#[unsafe(method(new))]
#[unsafe(method_family = new)]
pub fn new() -> Retained<Self>;
);
}
impl<ObjectType: Message> DefaultRetained for NSHashTable<ObjectType> {
#[inline]
fn default_retained() -> Retained<Self> {
Self::new()
}
}
/// ************** (void *) Hash table operations ***************
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashenumerator?language=objc)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NSHashEnumerator {
pub(crate) _pi: NSUInteger,
pub(crate) _si: NSUInteger,
pub(crate) _bs: *mut c_void,
}
unsafe impl Encode for NSHashEnumerator {
const ENCODING: Encoding = Encoding::Struct(
"?",
&[
<NSUInteger>::ENCODING,
<NSUInteger>::ENCODING,
<*mut c_void>::ENCODING,
],
);
}
unsafe impl RefEncode for NSHashEnumerator {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
extern "C-unwind" {
/// # Safety
///
/// `table` generic should be of the correct type.
pub fn NSFreeHashTable(table: &NSHashTable);
}
extern "C-unwind" {
/// # Safety
///
/// `table` generic should be of the correct type.
pub fn NSResetHashTable(table: &NSHashTable);
}
/// # Safety
///
/// - `table1` generic should be of the correct type.
/// - `table2` generic should be of the correct type.
#[inline]
pub unsafe extern "C-unwind" fn NSCompareHashTables(
table1: &NSHashTable,
table2: &NSHashTable,
) -> bool {
extern "C-unwind" {
fn NSCompareHashTables(table1: &NSHashTable, table2: &NSHashTable) -> Bool;
}
unsafe { NSCompareHashTables(table1, table2) }.as_bool()
}
/// # Safety
///
/// - `table` generic should be of the correct type.
/// - `zone` must be a valid pointer or null.
#[cfg(feature = "NSZone")]
#[inline]
pub unsafe extern "C-unwind" fn NSCopyHashTableWithZone(
table: &NSHashTable,
zone: *mut NSZone,
) -> Retained<NSHashTable> {
extern "C-unwind" {
fn NSCopyHashTableWithZone(table: &NSHashTable, zone: *mut NSZone) -> *mut NSHashTable;
}
let ret = unsafe { NSCopyHashTableWithZone(table, zone) };
unsafe { Retained::from_raw(ret) }
.expect("function was marked as returning non-null, but actually returned NULL")
}
/// # Safety
///
/// - `table` generic should be of the correct type.
/// - `pointer` must be a valid pointer or null.
#[inline]
pub unsafe extern "C-unwind" fn NSHashGet(
table: &NSHashTable,
pointer: *const c_void,
) -> NonNull<c_void> {
extern "C-unwind" {
fn NSHashGet(table: &NSHashTable, pointer: *const c_void) -> Option<NonNull<c_void>>;
}
let ret = unsafe { NSHashGet(table, pointer) };
ret.expect("function was marked as returning non-null, but actually returned NULL")
}
extern "C-unwind" {
/// # Safety
///
/// - `table` generic should be of the correct type.
/// - `pointer` must be a valid pointer or null.
pub fn NSHashInsert(table: &NSHashTable, pointer: *const c_void);
}
extern "C-unwind" {
/// # Safety
///
/// - `table` generic should be of the correct type.
/// - `pointer` must be a valid pointer or null.
pub fn NSHashInsertKnownAbsent(table: &NSHashTable, pointer: *const c_void);
}
extern "C-unwind" {
/// # Safety
///
/// - `table` generic should be of the correct type.
/// - `pointer` must be a valid pointer or null.
pub fn NSHashInsertIfAbsent(table: &NSHashTable, pointer: *const c_void) -> *mut c_void;
}
extern "C-unwind" {
/// # Safety
///
/// - `table` generic should be of the correct type.
/// - `pointer` must be a valid pointer or null.
pub fn NSHashRemove(table: &NSHashTable, pointer: *const c_void);
}
extern "C-unwind" {
/// # Safety
///
/// `table` generic should be of the correct type.
pub fn NSEnumerateHashTable(table: &NSHashTable) -> NSHashEnumerator;
}
extern "C-unwind" {
/// # Safety
///
/// `enumerator` must be a valid pointer.
pub fn NSNextHashEnumeratorItem(enumerator: NonNull<NSHashEnumerator>) -> *mut c_void;
}
extern "C-unwind" {
/// # Safety
///
/// `enumerator` must be a valid pointer.
pub fn NSEndHashTableEnumeration(enumerator: NonNull<NSHashEnumerator>);
}
extern "C-unwind" {
/// # Safety
///
/// `table` generic should be of the correct type.
pub fn NSCountHashTable(table: &NSHashTable) -> NSUInteger;
}
#[cfg(feature = "NSString")]
impl NSString {
/// # Safety
///
/// `table` generic should be of the correct type.
#[doc(alias = "NSStringFromHashTable")]
#[cfg(feature = "NSString")]
#[inline]
pub unsafe fn from_hash_table(table: &NSHashTable) -> Retained<NSString> {
extern "C-unwind" {
fn NSStringFromHashTable(table: &NSHashTable) -> *mut NSString;
}
let ret = unsafe { NSStringFromHashTable(table) };
unsafe { Retained::retain_autoreleased(ret) }
.expect("function was marked as returning non-null, but actually returned NULL")
}
}
/// # Safety
///
/// `table` generic should be of the correct type.
#[cfg(feature = "NSArray")]
#[inline]
pub unsafe extern "C-unwind" fn NSAllHashTableObjects(table: &NSHashTable) -> Retained<NSArray> {
extern "C-unwind" {
fn NSAllHashTableObjects(table: &NSHashTable) -> *mut NSArray;
}
let ret = unsafe { NSAllHashTableObjects(table) };
unsafe { Retained::retain_autoreleased(ret) }
.expect("function was marked as returning non-null, but actually returned NULL")
}
/// ************** Legacy ***************
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/foundation/nshashtablecallbacks?language=objc)
#[cfg(feature = "NSString")]
#[repr(C)]
#[allow(unpredictable_function_pointer_comparisons)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NSHashTableCallBacks {
pub hash:
Option<unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>) -> NSUInteger>,
pub isEqual: Option<
unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>, NonNull<c_void>) -> Bool,
>,
pub retain: Option<unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>)>,
pub release: Option<unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>)>,
pub describe:
Option<unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>) -> *mut NSString>,
}
#[cfg(feature = "NSString")]
unsafe impl Encode for NSHashTableCallBacks {
const ENCODING: Encoding = Encoding::Struct(
"?",
&[
<Option<
unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>) -> NSUInteger,
>>::ENCODING,
<Option<
unsafe extern "C-unwind" fn(
NonNull<NSHashTable>,
NonNull<c_void>,
NonNull<c_void>,
) -> Bool,
>>::ENCODING,
<Option<unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>)>>::ENCODING,
<Option<unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>)>>::ENCODING,
<Option<
unsafe extern "C-unwind" fn(NonNull<NSHashTable>, NonNull<c_void>) -> *mut NSString,
>>::ENCODING,
],
);
}
#[cfg(feature = "NSString")]
unsafe impl RefEncode for NSHashTableCallBacks {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
/// # Safety
///
/// - `call_backs` struct field 1 must be implemented correctly.
/// - `call_backs` struct field 2 must be implemented correctly.
/// - `call_backs` struct field 3 must be implemented correctly.
/// - `call_backs` struct field 4 must be implemented correctly.
/// - `call_backs` struct field 5 must be implemented correctly.
/// - `zone` must be a valid pointer or null.
#[cfg(all(feature = "NSString", feature = "NSZone"))]
#[inline]
pub unsafe extern "C-unwind" fn NSCreateHashTableWithZone(
call_backs: NSHashTableCallBacks,
capacity: NSUInteger,
zone: *mut NSZone,
) -> Retained<NSHashTable> {
extern "C-unwind" {
fn NSCreateHashTableWithZone(
call_backs: NSHashTableCallBacks,
capacity: NSUInteger,
zone: *mut NSZone,
) -> *mut NSHashTable;
}
let ret = unsafe { NSCreateHashTableWithZone(call_backs, capacity, zone) };
unsafe { Retained::from_raw(ret) }
.expect("function was marked as returning non-null, but actually returned NULL")
}
/// # Safety
///
/// - `call_backs` struct field 1 must be implemented correctly.
/// - `call_backs` struct field 2 must be implemented correctly.
/// - `call_backs` struct field 3 must be implemented correctly.
/// - `call_backs` struct field 4 must be implemented correctly.
/// - `call_backs` struct field 5 must be implemented correctly.
#[cfg(feature = "NSString")]
#[inline]
pub unsafe extern "C-unwind" fn NSCreateHashTable(
call_backs: NSHashTableCallBacks,
capacity: NSUInteger,
) -> Retained<NSHashTable> {
extern "C-unwind" {
fn NSCreateHashTable(
call_backs: NSHashTableCallBacks,
capacity: NSUInteger,
) -> *mut NSHashTable;
}
let ret = unsafe { NSCreateHashTable(call_backs, capacity) };
unsafe { Retained::from_raw(ret) }
.expect("function was marked as returning non-null, but actually returned NULL")
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsintegerhashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSIntegerHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsnonownedpointerhashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSNonOwnedPointerHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsnonretainedobjecthashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSNonRetainedObjectHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsobjecthashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSObjectHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsownedobjectidentityhashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSOwnedObjectIdentityHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsownedpointerhashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSOwnedPointerHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nspointertostructhashcallbacks?language=objc)
#[cfg(feature = "NSString")]
pub static NSPointerToStructHashCallBacks: NSHashTableCallBacks;
}
extern "C" {
/// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsinthashcallbacks?language=objc)
#[cfg(feature = "NSString")]
#[deprecated = "Not supported"]
pub static NSIntHashCallBacks: NSHashTableCallBacks;
}
#[cfg(feature = "NSString")]
#[deprecated = "renamed to `NSString::from_hash_table`"]
#[inline]
pub unsafe extern "C-unwind" fn NSStringFromHashTable(table: &NSHashTable) -> Retained<NSString> {
extern "C-unwind" {
fn NSStringFromHashTable(table: &NSHashTable) -> *mut NSString;
}
let ret = unsafe { NSStringFromHashTable(table) };
unsafe { Retained::retain_autoreleased(ret) }
.expect("function was marked as returning non-null, but actually returned NULL")
}