duchess 0.3.2

Silky smooth Java-Rust interop
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

use crate::{cast::Upcast, java::lang::Throwable, Error, Java, JavaObject, Local};

/// Possibly null reference to a Java object.
pub trait AsJRef<U> {
    fn as_jref(&self) -> Nullable<&U>;
}

/// Marker type used to indicate an attempt to dereference a null java reference.
/// See [`TryJDeref`][] trait.
pub struct NullJRef;

pub type Nullable<T> = Result<T, NullJRef>;

impl<'jvm, T, U> AsJRef<U> for T
where
    T: TryJDeref,
    T::Java: Upcast<U>,
    U: JavaObject,
{
    fn as_jref(&self) -> Nullable<&U> {
        let this = self.try_jderef()?;
        Ok(unsafe { std::mem::transmute(this) })
    }
}

/// Reference to a Java object that may or may not be null.
/// Implemented both by non-null references like `Java<java::lang::Object>`
/// or `&java::lang::Object` and by maybe-null references like `Option<Java<java::lang::Object>>`.
pub trait TryJDeref {
    /// The Java type (e.g., [`java::lang::Object`][`crate::java::lang::Object`]).
    type Java: JavaObject;

    /// Dereference to a plain reference to the java object, or `Err` if it is null.
    fn try_jderef(&self) -> Nullable<&Self::Java>;
}

/// Reference to a Java object that cannot be null (e.g., `Java<java::lang::Object>`).
pub trait JDeref: TryJDeref {
    /// Dereference to a plain reference to the java object.
    fn jderef(&self) -> &Self::Java;
}

impl<T> TryJDeref for &T
where
    T: TryJDeref,
{
    type Java = T::Java;

    fn try_jderef(&self) -> Nullable<&T::Java> {
        T::try_jderef(self)
    }
}

impl<T> JDeref for &T
where
    T: JDeref,
{
    fn jderef(&self) -> &T::Java {
        T::jderef(self)
    }
}

impl<T> TryJDeref for Local<'_, T>
where
    T: JavaObject,
{
    type Java = T;

    fn try_jderef(&self) -> Nullable<&T> {
        Ok(self)
    }
}

impl<T> JDeref for Local<'_, T>
where
    T: JavaObject,
{
    fn jderef(&self) -> &T {
        self
    }
}

impl<T> TryJDeref for Java<T>
where
    T: JavaObject,
{
    type Java = T;

    fn try_jderef(&self) -> Nullable<&T> {
        Ok(self)
    }
}

impl<T> JDeref for Java<T>
where
    T: JavaObject,
{
    fn jderef(&self) -> &T {
        self
    }
}

impl<T> TryJDeref for Option<T>
where
    T: TryJDeref,
{
    type Java = T::Java;

    fn try_jderef(&self) -> Result<&T::Java, NullJRef> {
        match self {
            Some(r) => r.try_jderef(),
            None => Err(NullJRef),
        }
    }
}

impl<T> From<NullJRef> for Error<T>
where
    T: AsJRef<Throwable>,
{
    fn from(NullJRef: NullJRef) -> Self {
        Error::NullDeref
    }
}