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

use std::marker::PhantomData;

use crate::Jvm;
use crate::{jvm::JavaObjectExt, refs::AsJRef, JavaObject, JvmOp, Local, TryJDeref};

/// A trait to represent safe upcast operations for a [`JavaObject`].
///
/// # Safety
///
/// Inherits the rules of [`JavaObject`], but also `S` must be a valid superclass or implemented interface of `Self`.
/// XX: would this actually allow unsafe behavior in a JNI call? or is it already checked/enforced?
///
/// XX: having to impl `Upcast<T>` for T on each struct is pretty annoying to get `AsJRef<T>` to work without conflicts
pub unsafe trait Upcast<S: JavaObject>: JavaObject {}

#[derive_where::derive_where(Clone)]
#[derive_where(Copy; J: Copy)]
pub struct TryDowncast<J: JvmOp, To> {
    op: J,
    _marker: PhantomData<To>,
}

impl<J, To> TryDowncast<J, To>
where
    J: JvmOp,
    for<'jvm> J::Output<'jvm>: TryJDeref,
    To: for<'jvm> Upcast<<J::Output<'jvm> as TryJDeref>::Java>,
{
    pub(crate) fn new(op: J) -> Self {
        Self {
            op,
            _marker: PhantomData,
        }
    }
}

impl<J, To> JvmOp for TryDowncast<J, To>
where
    J: JvmOp,
    for<'jvm> J::Output<'jvm>: TryJDeref,
    To: for<'jvm> Upcast<<J::Output<'jvm> as TryJDeref>::Java>,
{
    type Output<'jvm> = Result<Local<'jvm, To>, J::Output<'jvm>>;

    fn do_jni<'jvm>(self, jvm: &mut Jvm<'jvm>) -> crate::LocalResult<'jvm, Self::Output<'jvm>> {
        let instance = self.op.do_jni(jvm)?;
        let instance_raw = instance.try_jderef()?.as_raw();

        let class = To::class(jvm)?;
        let class_raw = class.as_raw();

        let env = jvm.env();
        let is_inst = unsafe {
            env.invoke_unchecked(
                |env| env.IsInstanceOf,
                |env, f| f(env, instance_raw.as_ptr(), class_raw.as_ptr()),
            ) == jni_sys::JNI_TRUE
        };

        if is_inst {
            // SAFETY: just shown that jobject instanceof To::class
            let casted = unsafe { std::mem::transmute::<&_, &To>(instance.try_jderef()?) };
            Ok(Ok(jvm.local(casted)))
        } else {
            Ok(Err(instance))
        }
    }
}

#[derive_where::derive_where(Clone)]
#[derive_where(Copy; J: Copy)]
pub struct AsUpcast<J: JvmOp, To> {
    op: J,
    _marker: PhantomData<To>,
}

impl<J, To> AsUpcast<J, To>
where
    J: JvmOp,
    for<'jvm> J::Output<'jvm>: AsJRef<To>,
    To: JavaObject,
{
    pub(crate) fn new(op: J) -> Self {
        Self {
            op,
            _marker: PhantomData,
        }
    }
}

impl<J, To> JvmOp for AsUpcast<J, To>
where
    J: JvmOp,
    for<'jvm> J::Output<'jvm>: AsJRef<To>,
    To: JavaObject,
{
    type Output<'jvm> = Local<'jvm, To>;

    fn do_jni<'jvm>(self, jvm: &mut Jvm<'jvm>) -> crate::LocalResult<'jvm, Self::Output<'jvm>> {
        let instance = self.op.do_jni(jvm)?;

        if cfg!(debug_assertions) {
            let class = To::class(jvm)?;
            let class_raw = class.as_raw();

            let instance_raw = instance.as_jref()?.as_raw();
            assert!(unsafe {
                jvm.env().invoke_unchecked(
                    |env| env.IsInstanceOf,
                    |env, f| f(env, instance_raw.as_ptr(), class_raw.as_ptr()),
                ) == jni_sys::JNI_TRUE
            });
        }

        // Safety: From: Upcast<To>
        Ok(jvm.local(instance.as_jref()?))
    }
}