objc2 0.4.1

Objective-C interface and runtime bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::mutability::{
    Immutable, ImmutableWithMutableSubclass, InteriorMutable, MainThreadOnly, Mutable,
    MutableWithImmutableSuperclass, Root,
};
use crate::rc::Id;
use crate::{msg_send_id, ClassType, ProtocolType};

/// Helper trait for [`NSCopying`] and [`NSMutableCopying`].
///
/// This is needed since those two can't have associated types themselves (at
/// least not if they want to be usable as `ProtocolObject<dyn NSCopying>`),
/// and because the return type of those differ if the class has a mutable or
/// an immutable counterpart (as is the case for `NSString` and
/// `NSMutableString`).
pub trait Copyhelper<T: ?Sized> {
    /// The output type of [`NSCopying`] for the given `T`.
    type CopyOutput: ?Sized + ClassType;
    /// The output type of [`NSMutableCopying`] for the given `T`.
    type MutableCopyOutput: ?Sized + ClassType;

    // TODO: Use this to autogenerate `ToOwned` impls
    #[doc(hidden)]
    fn __do_copy(t: &T) -> Id<T>;
}
impl<T: NSCopying + ClassType<Mutability = Root>> Copyhelper<T> for Root {
    type CopyOutput = T;
    type MutableCopyOutput = T;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.copy()
    }
}
impl<T: NSCopying + ClassType<Mutability = Immutable>> Copyhelper<T> for Immutable {
    type CopyOutput = T;
    type MutableCopyOutput = T;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.retain()
    }
}
impl<T: NSCopying + ClassType<Mutability = Mutable>> Copyhelper<T> for Mutable {
    type CopyOutput = T;
    type MutableCopyOutput = T;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.copy()
    }
}
impl<T, S> Copyhelper<T> for ImmutableWithMutableSubclass<S>
where
    T: NSCopying + ClassType<Mutability = ImmutableWithMutableSubclass<S>>,
    S: ClassType<Mutability = MutableWithImmutableSuperclass<T>>,
{
    type CopyOutput = T;
    type MutableCopyOutput = S;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.copy()
    }
}
impl<T, S> Copyhelper<T> for MutableWithImmutableSuperclass<S>
where
    T: NSMutableCopying + ClassType<Mutability = MutableWithImmutableSuperclass<S>>,
    S: ClassType<Mutability = ImmutableWithMutableSubclass<T>>,
{
    type CopyOutput = S;
    type MutableCopyOutput = T;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.mutableCopy()
    }
}
impl<T: NSCopying + ClassType<Mutability = InteriorMutable>> Copyhelper<T> for InteriorMutable {
    type CopyOutput = T;
    type MutableCopyOutput = T;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.retain()
    }
}
impl<T: NSCopying + ClassType<Mutability = MainThreadOnly>> Copyhelper<T> for MainThreadOnly {
    type CopyOutput = T;
    type MutableCopyOutput = T;

    #[inline]
    fn __do_copy(t: &T) -> Id<T> {
        t.retain()
    }
}

/// A protocol to provide functional copies of objects.
///
/// This is similar to Rust's [`Clone`] trait, along with sharing a few
/// similarities to the [`std::borrow::ToOwned`] trait with regards to the
/// output type.
///
/// See [Apple's documentation][apple-doc] for details.
///
/// [apple-doc]: https://developer.apple.com/documentation/foundation/nscopying
#[allow(clippy::missing_safety_doc)] // Same as all other traits
pub unsafe trait NSCopying {
    /// Returns a new instance that's a copy of the receiver.
    ///
    /// The output type is usually `Self`, but e.g. `NSMutableString` returns
    /// `NSString`.
    fn copy(&self) -> Id<<Self::Mutability as Copyhelper<Self>>::CopyOutput>
    where
        Self: Sized + ClassType,
        Self::Mutability: Copyhelper<Self>,
    {
        unsafe { msg_send_id![self, copy] }
    }
}

crate::__inner_extern_protocol!(
    ()
    (NSCopying)
    (dyn NSCopying)
    ("NSCopying")
);

/// A protocol to provide mutable copies of objects.
///
/// Only classes that have an “immutable vs. mutable” distinction should adopt
/// this protocol.
///
/// See [Apple's documentation][apple-doc] for details.
///
/// [apple-doc]: https://developer.apple.com/documentation/foundation/nsmutablecopying
#[allow(clippy::missing_safety_doc)] // Same as all other traits
pub unsafe trait NSMutableCopying {
    /// Returns a new instance that's a mutable copy of the receiver.
    ///
    /// The output type is the mutable counterpart of the object. E.g. both
    /// `NSString` and `NSMutableString` return `NSMutableString`.
    #[allow(non_snake_case)]
    fn mutableCopy(&self) -> Id<<Self::Mutability as Copyhelper<Self>>::MutableCopyOutput>
    where
        Self: Sized + ClassType,
        Self::Mutability: Copyhelper<Self>,
    {
        unsafe { msg_send_id![self, mutableCopy] }
    }
}

crate::__inner_extern_protocol!(
    ()
    (NSMutableCopying)
    (dyn NSMutableCopying)
    ("NSMutableCopying")
);