@@ -19,15 +19,35 @@ pub unsafe trait HasFFI : Sized {
1919/// Indicates that a given Servo type has the same layout
2020/// as the corresponding HasFFI::FFIType type
2121pub unsafe trait HasSimpleFFI : HasFFI {
22+ #[ inline]
23+ /// Given a Servo-side reference, converts it to an
24+ /// FFI-safe reference which can be passed to Gecko
25+ ///
26+ /// &ServoType -> &GeckoType
2227fn as_ffi ( & self ) -> & Self :: FFIType {
2328 unsafe { transmute ( self ) }
2429 }
30+ #[ inline]
31+ /// Given a Servo-side mutable reference, converts it to an
32+ /// FFI-safe mutable reference which can be passed to Gecko
33+ ///
34+ /// &mut ServoType -> &mut GeckoType
2535fn as_ffi_mut ( & mut self ) -> & mut Self :: FFIType {
2636 unsafe { transmute ( self ) }
2737 }
38+ #[ inline]
39+ /// Given an FFI-safe reference obtained from Gecko
40+ /// converts it to a Servo-side reference
41+ ///
42+ /// &GeckoType -> &ServoType
2843fn from_ffi ( ffi : & Self :: FFIType ) -> & Self {
2944 unsafe { transmute ( ffi) }
3045 }
46+ #[ inline]
47+ /// Given an FFI-safe mutable reference obtained from Gecko
48+ /// converts it to a Servo-side mutable reference
49+ ///
50+ /// &mut GeckoType -> &mut ServoType
3151fn from_ffi_mut ( ffi : & mut Self :: FFIType ) -> & mut Self {
3252 unsafe { transmute ( ffi) }
3353 }
@@ -36,6 +56,7 @@ pub unsafe trait HasSimpleFFI : HasFFI {
3656/// Indicates that the given Servo type is passed over FFI
3757/// as a Box
3858pub unsafe trait HasBoxFFI : HasSimpleFFI {
59+ #[ inline]
3960 fn into_ffi ( self : Box < Self > ) -> Owned < Self :: FFIType > {
4061 unsafe { transmute ( self ) }
4162 }
@@ -67,25 +88,47 @@ pub unsafe trait HasArcFFI : HasFFI {
6788}
6889
6990#[ repr( C ) ]
70- /// Gecko-FFI-safe borrowed Arc (&T where T is an ArcInner).
91+ /// Gecko-FFI-safe borrowed type
7192/// This can be null.
7293pub struct Borrowed < ' a , T : ' a > {
7394 ptr : * const T ,
7495 _marker : PhantomData < & ' a T > ,
7596}
7697
98+ #[ repr( C ) ]
99+ /// Gecko-FFI-safe mutably borrowed type
100+ /// This can be null.
101+ pub struct BorrowedMut < ' a , T : ' a > {
102+ ptr : * mut T ,
103+ _marker : PhantomData < & ' a mut T > ,
104+ }
105+
77106// manual impls because derive doesn't realize that `T: Clone` isn't necessary
78107impl < ' a , T > Copy for Borrowed < ' a , T > { }
79108
80109impl < ' a , T > Clone for Borrowed < ' a , T > {
110+ #[ inline]
81111 fn clone ( & self ) -> Self { * self }
82112}
83113
84114impl < ' a , T > Borrowed < ' a , T > {
115+ #[ inline]
85116 pub fn is_null ( & self ) -> bool {
86117 self . ptr == ptr:: null ( )
87118 }
88119
120+ #[ inline]
121+ /// Like Deref, but gives an Option
122+ pub fn borrow_opt ( self ) -> Option < & ' a T > {
123+ if self . is_null ( ) {
124+ None
125+ } else {
126+ Some ( unsafe { & * self . ptr } )
127+ }
128+ }
129+
130+ #[ inline]
131+ /// Borrowed<GeckoType> -> Option<&Arc<ServoType>>
89132pub fn as_arc_opt < U > ( & self ) -> Option < & Arc < U > > where U : HasArcFFI < FFIType = T > {
90133 unsafe {
91134 if self . is_null ( ) {
@@ -96,11 +139,71 @@ impl<'a, T> Borrowed<'a, T> {
96139 }
97140 }
98141
142+ #[ inline]
99143 /// Converts a borrowed FFI reference to a borrowed Arc.
100- /// Panics on null
144+ /// Panics on null.
145+ ///
146+ /// &Borrowed<GeckoType> -> &Arc<ServoType>
101147pub fn as_arc < U > ( & self ) -> & Arc < U > where U : HasArcFFI < FFIType = T > {
102148 self . as_arc_opt ( ) . unwrap ( )
103149 }
150+
151+ #[ inline]
152+ /// Borrowed<ServoType> -> Borrowed<GeckoType>
153+ pub fn as_ffi ( & self ) -> Borrowed < <Self as HasFFI >:: FFIType > where Self : HasSimpleFFI {
154+ unsafe { transmute ( self ) }
155+ }
156+
157+ #[ inline]
158+ /// Borrowed<GeckoType> -> Borrowed<ServoType>
159+ pub fn from_ffi < U > ( self ) -> Borrowed < ' a , U > where U : HasSimpleFFI < FFIType = T > {
160+ unsafe { transmute ( self ) }
161+ }
162+
163+ #[ inline]
164+ /// Borrowed<GeckoType> -> &ServoType
165+ pub fn as_servo_ref < U > ( self ) -> Option < & ' a U > where U : HasSimpleFFI < FFIType = T > {
166+ self . borrow_opt ( ) . map ( HasSimpleFFI :: from_ffi)
167+ }
168+ }
169+
170+ impl < ' a , T > BorrowedMut < ' a , T > {
171+ #[ inline]
172+ /// Like DerefMut, but gives an Option
173+ pub fn borrow_mut_opt ( self ) -> Option < & ' a mut T > {
174+ // We have two choices for the signature here, it can either be
175+ // Self -> Option<&'a mut T> or
176+ // &'b mut Self -> Option<'b mut T>
177+ // The former consumes the BorrowedMut (which isn't Copy),
178+ // which can be annoying. The latter only temporarily
179+ // borrows it, so the return value can't exit the scope
180+ // even if Self has a longer lifetime ('a)
181+ //
182+ // This is basically the implicit "reborrow" pattern used with &mut
183+ // not cleanly translating to our custom types.
184+
185+ // I've chosen the former solution -- you can manually convert back
186+ // if you need to reuse the BorrowedMut.
187+ if self . is_null ( ) {
188+ None
189+ } else {
190+ Some ( unsafe { & mut * self . ptr } )
191+ }
192+ }
193+
194+ #[ inline]
195+ /// BorrowedMut<GeckoType> -> &mut ServoType
196+ pub fn as_servo_mut_ref < U > ( self ) -> Option < & ' a mut U > where U : HasSimpleFFI < FFIType = T > {
197+ self . borrow_mut_opt ( ) . map ( HasSimpleFFI :: from_ffi_mut)
198+ }
199+ }
200+
201+ // technically not
202+ impl < ' a , T > Deref for BorrowedMut < ' a , T > {
203+ type Target = Borrowed < ' a , T > ;
204+ fn deref ( & self ) -> & Self :: Target {
205+ unsafe { transmute ( self ) }
206+ }
104207}
105208
106209#[ repr( C ) ]
@@ -112,17 +215,23 @@ pub struct Strong<T> {
112215}
113216
114217impl < T > Strong < T > {
218+ #[ inline]
115219 pub fn is_null ( & self ) -> bool {
116220 self . ptr == ptr:: null ( )
117221 }
118222
119- /// Given a non-null strong FFI reference, converts it into an Arc.
223+ #[ inline]
224+ /// Given a non-null strong FFI reference,
225+ /// converts it into a servo-side Arc
120226/// Panics on null.
227+ ///
228+ /// Strong<GeckoType> -> Arc<ServoType>
121229pub fn into_arc < U > ( self ) -> Arc < U > where U : HasArcFFI < FFIType = T > {
122230 assert ! ( !self . is_null( ) ) ;
123231 unsafe { transmute ( self ) }
124232 }
125233
234+ #[ inline]
126235 /// Produces a null strong FFI reference
127236pub fn null_strong ( ) -> Self {
128237 unsafe { transmute ( ptr:: null :: < T > ( ) ) }
@@ -132,16 +241,22 @@ impl<T> Strong<T> {
132241pub unsafe trait FFIArcHelpers {
133242 type Inner : HasArcFFI ;
134243 /// Converts an Arc into a strong FFI reference.
244+ ///
245+ /// Arc<ServoType> -> Strong<GeckoType>
135246fn into_strong ( self ) -> Strong < <Self :: Inner as HasFFI >:: FFIType > ;
136247 /// Produces a borrowed FFI reference by borrowing an Arc.
248+ ///
249+ /// &Arc<ServoType> -> Borrowed<GeckoType>
137250fn as_borrowed ( & self ) -> Borrowed < <Self :: Inner as HasFFI >:: FFIType > ;
138251}
139252
140253unsafe impl < T : HasArcFFI > FFIArcHelpers for Arc < T > {
141254 type Inner = T ;
255+ #[ inline]
142256 fn into_strong ( self ) -> Strong < T :: FFIType > {
143257 unsafe { transmute ( self ) }
144258 }
259+ #[ inline]
145260 fn as_borrowed ( & self ) -> Borrowed < T :: FFIType > {
146261 let borrowedptr = self as * const Arc < T > as * const Borrowed < T :: FFIType > ;
147262 unsafe { ptr:: read ( borrowedptr) }
@@ -157,9 +272,13 @@ pub struct Owned<T> {
157272}
158273
159274impl < T > Owned < T > {
275+ /// Owned<GeckoType> -> Box<ServoType>
160276pub fn into_box < U > ( self ) -> Box < T > where U : HasBoxFFI < FFIType = T > {
161277 unsafe { transmute ( self ) }
162278 }
279+ pub fn maybe ( self ) -> MaybeOwned < T > {
280+ unsafe { transmute ( self ) }
281+ }
163282}
164283
165284impl < T > Deref for Owned < T > {
@@ -174,3 +293,33 @@ impl<T> DerefMut for Owned<T> {
174293 unsafe { & mut * self . ptr }
175294 }
176295}
296+
297+ #[ repr( C ) ]
298+ /// Gecko-FFI-safe owned pointer
299+ /// Can be null
300+ pub struct MaybeOwned < T > {
301+ ptr : * mut T ,
302+ _marker : PhantomData < T > ,
303+ }
304+
305+ impl < T > MaybeOwned < T > {
306+ pub fn is_null ( & self ) -> bool {
307+ self . ptr == ptr:: null_mut ( )
308+ }
309+ /// MaybeOwned<GeckoType> -> Option<Box<ServoType>>
310+ pub fn into_box_opt < U > ( self ) -> Option < Box < T > > where U : HasBoxFFI < FFIType = T > {
311+ if self . is_null ( ) {
312+ None
313+ } else {
314+ Some ( unsafe { transmute ( self ) } )
315+ }
316+ }
317+
318+ pub fn borrow ( & self ) -> Borrowed < T > {
319+ unsafe { transmute ( self ) }
320+ }
321+
322+ pub fn borrow_mut ( & self ) -> BorrowedMut < T > {
323+ unsafe { transmute ( self ) }
324+ }
325+ }
0 commit comments