glib/
clone.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use crate::prelude::*;
4use std::{
5    marker::PhantomData,
6    rc::{self, Rc},
7    sync::{self, Arc},
8};
9
10// rustdoc-stripper-ignore-next
11/// Trait for generalizing downgrading a strong reference to a weak reference.
12pub trait Downgrade
13where
14    Self: Sized,
15{
16    // rustdoc-stripper-ignore-next
17    /// Weak reference type.
18    type Weak: Upgrade;
19
20    // rustdoc-stripper-ignore-next
21    /// Downgrade to a weak reference.
22    fn downgrade(&self) -> Self::Weak;
23}
24
25// rustdoc-stripper-ignore-next
26/// Trait for generalizing upgrading a weak reference to a strong reference.
27pub trait Upgrade
28where
29    Self: Sized,
30{
31    // rustdoc-stripper-ignore-next
32    /// Strong reference type.
33    type Strong;
34
35    // rustdoc-stripper-ignore-next
36    /// Try upgrading a weak reference to a strong reference.
37    fn upgrade(&self) -> Option<Self::Strong>;
38}
39
40impl<T: Downgrade + ObjectType> Upgrade for crate::WeakRef<T> {
41    type Strong = T;
42
43    fn upgrade(&self) -> Option<Self::Strong> {
44        self.upgrade()
45    }
46}
47
48impl<T> Downgrade for PhantomData<T> {
49    type Weak = PhantomData<T>;
50
51    fn downgrade(&self) -> Self::Weak {
52        PhantomData
53    }
54}
55
56impl<T: Downgrade> Downgrade for &T {
57    type Weak = T::Weak;
58
59    fn downgrade(&self) -> Self::Weak {
60        T::downgrade(*self)
61    }
62}
63
64impl<T> Downgrade for Arc<T> {
65    type Weak = sync::Weak<T>;
66
67    fn downgrade(&self) -> Self::Weak {
68        Arc::downgrade(self)
69    }
70}
71
72impl<T> Upgrade for PhantomData<T> {
73    type Strong = PhantomData<T>;
74
75    fn upgrade(&self) -> Option<Self::Strong> {
76        Some(PhantomData)
77    }
78}
79
80impl<T> Upgrade for sync::Weak<T> {
81    type Strong = Arc<T>;
82
83    fn upgrade(&self) -> Option<Self::Strong> {
84        self.upgrade()
85    }
86}
87
88impl<T> Downgrade for Rc<T> {
89    type Weak = rc::Weak<T>;
90
91    fn downgrade(&self) -> Self::Weak {
92        Rc::downgrade(self)
93    }
94}
95
96impl<T> Upgrade for rc::Weak<T> {
97    type Strong = Rc<T>;
98
99    fn upgrade(&self) -> Option<Self::Strong> {
100        self.upgrade()
101    }
102}