ejni 0.1.0

Library to make working with JNI more pleasant
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

use crate::abstractions::iterator::Iterator;
use crate::class::Class;
use crate::object::Object;
use jni::errors::Result;
use jni::objects::JValue;
use jni::sys::_jobject;
use jni::JNIEnv;

/// Wrapper around `java.util.Set`
pub struct Set<'a> {
    /// The Set itself
    pub inner: Object<'a>,

    /// The Class contained in the Set
    pub class: Class<'a>,

    env: &'a JNIEnv<'a>,
}

#[allow(clippy::from_over_into)]
impl<'a> Into<*mut _jobject> for Set<'a> {
    fn into(self) -> *mut _jobject {
        self.inner.inner.into_inner()
    }
}

impl<'a> Drop for Set<'a> {
    fn drop(&mut self) {
        let _ = self.env.delete_local_ref(self.inner.inner);
    }
}

impl<'a> Set<'a> {
    /// Create a new Set. The caller must guarantee that the passed in Object implements Set and is not null.
    pub fn new(env: &'a JNIEnv<'a>, object: Object<'a>, class: Class<'a>) -> Self {
        Self {
            inner: object,
            class,
            env,
        }
    }

    /// Constructs a new, empty set; the backing HashMap instance has default initial capacity (16) and load factor (0.75).
    pub fn hashset(env: &'a JNIEnv<'a>, v_class: Class<'a>) -> Result<Self> {
        let hashset = env.new_object("java/util/HashSet", "()V", &[])?;
        Ok(Self {
            inner: Object::new(env, hashset, Class::HashSet(env)?),
            class: v_class,
            env,
        })
    }

    /// Constructs a new, empty set; the backing HashMap instance has the specified initial capacity and default load factor (0.75).
    pub fn hashset_with_capacity(
        env: &'a JNIEnv<'a>,
        v_class: Class<'a>,
        initial_capacity: i32,
    ) -> Result<Self> {
        let hashset = env.new_object(
            "java/util/HashSet",
            "(I)V",
            &[JValue::Int(initial_capacity)],
        )?;
        Ok(Self {
            inner: Object::new(env, hashset, Class::HashSet(env)?),
            class: v_class,
            env,
        })
    }

    /// Constructs a new, empty set; the backing HashMap instance has the specified initial capacity and the specified load factor.
    pub fn hashset_with_capacity_and_load_factor(
        env: &'a JNIEnv<'a>,
        v_class: Class<'a>,
        initial_capacity: i32,
        load_factor: f32,
    ) -> Result<Self> {
        let hashset = env.new_object(
            "java/util/HashSet",
            "(IF)V",
            &[JValue::Int(initial_capacity), JValue::Float(load_factor)],
        )?;
        Ok(Self {
            inner: Object::new(env, hashset, Class::HashSet(env)?),
            class: v_class,
            env,
        })
    }

    /// Returns the number of elements in this set (its cardinality).
    pub fn size(&self) -> Result<i32> {
        let size = self.env.call_method(self.inner.inner, "size", "()I", &[])?;
        size.i()
    }

    /// Returns an iterator over the elements in this set.
    pub fn iterator(&self) -> Result<Iterator<'a>> {
        let iterator =
            self.env
                .call_method(self.inner.inner, "iterator", "()Ljava/util/Iterator;", &[])?;
        let object = Object::new(self.env, iterator.l()?, Class::Iterator(self.env)?);
        let iterator = Iterator::new(self.env, object, self.class.clone());
        Ok(iterator)
    }

    /// Convert the java.util.Set to a Vec
    pub fn to_vec(&self) -> Result<Vec<Object<'a>>> {
        let mut vec = Vec::new();
        let iter = self.iterator()?;
        while let Some(i) = iter.next()? {
            vec.push(i);
        }

        Ok(vec)
    }
}